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

Merge branch 'development' of https://github.com/aws-lumberyard-dev/o3de into mnaumov/2372

Browse Source
This commit is contained in:
mnaumov
2021-08-16 15:23:34 -07:00
parent e633b5bdc7 11ac57d86f
commit d5b92fa93a
878 changed files with 10002 additions and 25721 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Editor/Animation/SkeletonHierarchy.cpp
-149
View File
@@ -1,149 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "SkeletonHierarchy.h"
using namespace Skeleton;
/*
CHierarchy
*/
CHierarchy::CHierarchy()
{
}
CHierarchy::~CHierarchy()
{
}
//
uint32 CHierarchy::AddNode(const char* name, const QuatT& pose, int32 parent)
{
int32 index = FindNodeIndexByName(name);
if (index < 0)
{
m_nodes.push_back(SNode());
index = int32(m_nodes.size() - 1);
}
m_nodes[index].name = name;
m_nodes[index].pose = pose;
m_nodes[index].parent = parent;
return uint32(index);
}
int32 CHierarchy::FindNodeIndexByName(const char* name) const
{
uint32 count = uint32(m_nodes.size());
for (uint32 i = 0; i < count; ++i)
{
if (::_stricmp(m_nodes[i].name, name))
{
continue;
}
return i;
}
return -1;
}
const CHierarchy::SNode* CHierarchy::FindNode(const char* name) const
{
int32 index = FindNodeIndexByName(name);
return index < 0 ? nullptr : &m_nodes[index];
}
void CHierarchy::CreateFrom(IDefaultSkeleton* pIDefaultSkeleton)
{
const uint32 jointCount = pIDefaultSkeleton->GetJointCount();
m_nodes.clear();
m_nodes.reserve(jointCount);
for (uint32 i = 0; i < jointCount; ++i)
{
m_nodes.push_back(SNode());
m_nodes.back().name = pIDefaultSkeleton->GetJointNameByID(int32(i));
m_nodes.back().pose = pIDefaultSkeleton->GetDefaultAbsJointByID(int32(i));
m_nodes.back().parent = pIDefaultSkeleton->GetJointParentIDByID(int32(i));
}
ValidateReferences();
}
void CHierarchy::ValidateReferences()
{
uint32 nodeCount = m_nodes.size();
if (!nodeCount)
{
return;
}
for (uint32 i = 0; i < nodeCount; ++i)
{
if (m_nodes[i].parent < nodeCount)
{
continue;
}
m_nodes[i].parent = -1;
}
}
void CHierarchy::AbsoluteToRelative(const QuatT* pSource, QuatT* pDestination)
{
uint32 count = uint32(m_nodes.size());
std::vector<QuatT> absolutes(count);
for (uint32 i = 0; i < count; ++i)
{
absolutes[i] = pSource[i];
}
for (uint32 i = 0; i < count; ++i)
{
int32 parent = m_nodes[i].parent;
if (parent < 0)
{
pDestination[i] = absolutes[i];
continue;
}
pDestination[i].t = (absolutes[i].t - absolutes[parent].t) * absolutes[parent].q;
pDestination[i].q = absolutes[parent].q.GetInverted() * absolutes[i].q;
}
}
bool CHierarchy::SerializeTo(XmlNodeRef& node)
{
XmlNodeRef hierarchy = node->newChild("Hierarchy");
uint32 nodeCount = uint32(m_nodes.size());
std::vector<IXmlNode*> nodes(nodeCount);
for (uint32 i = 0; i < nodeCount; ++i)
{
XmlNodeRef parent = hierarchy;
if (m_nodes[i].parent > -1)
{
parent = nodes[m_nodes[i].parent];
}
nodes[i] = parent->newChild("Node");
nodes[i]->setAttr("name", m_nodes[i].name);
}
return true;
}
Code/Editor/Animation/SkeletonHierarchy.h
-57
View File
@@ -1,57 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_ANIMATION_SKELETONHIERARCHY_H
#define CRYINCLUDE_EDITOR_ANIMATION_SKELETONHIERARCHY_H
#pragma once
namespace Skeleton {
class CHierarchy
: public _reference_target_t
{
public:
struct SNode
{
string name;
QuatT pose;
int32 parent;
/* TODO: Implement
uint32 childrenIndex;
uint32 childrenCount;
*/
};
public:
CHierarchy();
~CHierarchy();
public:
uint32 AddNode(const char* name, const QuatT& pose, int32 parent = -1);
uint32 GetNodeCount() const { return uint32(m_nodes.size()); }
SNode* GetNode(uint32 index) { return &m_nodes[index]; }
const SNode* GetNode(uint32 index) const { return &m_nodes[index]; }
int32 FindNodeIndexByName(const char* name) const;
const SNode* FindNode(const char* name) const;
void ClearNodes() { m_nodes.clear(); }
void CreateFrom(IDefaultSkeleton* rIDefaultSkeleton);
void ValidateReferences();
void AbsoluteToRelative(const QuatT* pSource, QuatT* pDestination);
bool SerializeTo(XmlNodeRef& node);
private:
std::vector<SNode> m_nodes;
};
} // namespace Skeleton
#endif // CRYINCLUDE_EDITOR_ANIMATION_SKELETONHIERARCHY_H
Code/Editor/Animation/SkeletonMapper.cpp
-368
View File
@@ -1,368 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "SkeletonMapper.h"
using namespace Skeleton;
/*
CMapper
*/
CMapper::CMapper()
{
}
CMapper::~CMapper()
{
}
//
void CMapper::CreateFromHierarchy()
{
m_nodes.clear();
uint32 nodeCount = m_hierarchy.GetNodeCount();
m_nodes.resize(nodeCount);
}
//
uint32 CMapper::CreateLocation(const char* name)
{
int32 index = FindLocation(name);
if (index < 1)
{
CMapperLocation* pLocation = new CMapperLocation();
pLocation->SetName(name);
m_locations.push_back(pLocation);
}
return uint32(m_locations.size() - 1);
}
void CMapper::ClearLocations()
{
uint32 count = uint32(m_nodes.size());
for (uint32 i = 0; i < count; ++i)
{
m_nodes[i].position = nullptr;
m_nodes[i].orientation = nullptr;
}
m_locations.clear();
}
int32 CMapper::FindLocation(const char* name) const
{
uint32 count = uint32(m_locations.size());
for (uint32 i = 0; i < count; ++i)
{
if (::_stricmp(m_locations[i]->GetName(), name))
{
continue;
}
return int32(i);
}
return -1;
}
void CMapper::SetLocation(CMapperLocation& location)
{
int32 index = FindLocation(location.GetName());
if (index < 0)
{
m_locations.push_back(&location);
return;
}
m_locations[index] = &location;
}
//
bool CMapper::CreateLocationsHierarchy(uint32 index, CHierarchy& hierarchy, int32 hierarchyParent)
{
if (NodeHasLocation(index))
{
const CHierarchy::SNode* pNode = m_hierarchy.GetNode(index);
uint32 nodeIndex = hierarchy.AddNode(pNode->name, pNode->pose, hierarchyParent);
hierarchyParent = uint32(nodeIndex);
}
std::vector<uint32> children;
GetChildrenIndices(index, children);
uint32 childCount = uint32(children.size());
for (uint32 i = 0; i < childCount; ++i)
{
CreateLocationsHierarchy(children[i], hierarchy, hierarchyParent);
}
return hierarchy.GetNodeCount() != 0;
}
bool CMapper::CreateLocationsHierarchy(CHierarchy& hierarchy)
{
hierarchy.ClearNodes();
if (!CreateLocationsHierarchy(0, hierarchy, -1))
{
return false;
}
hierarchy.ValidateReferences();
return true;
}
void CMapper::Map(QuatT* pResult)
{
uint32 outputCount = m_hierarchy.GetNodeCount();
std::vector<Quat> absolutes(outputCount);
for (uint32 i = 0; i < outputCount; ++i)
{
pResult[i].SetIdentity();
absolutes[i].SetIdentity();
CHierarchy::SNode* pNode = m_hierarchy.GetNode(i);
if (!pNode)
{
continue;
}
CHierarchy::SNode* pParent = pNode->parent < 0 ?
nullptr : m_hierarchy.GetNode(pNode->parent);
if (pParent)
{
pResult[i].t =
(pNode->pose.t - pParent->pose.t) * pParent->pose.q;
}
if (m_nodes[i].position)
{
pResult[i].t = m_nodes[i].position->Compute().t;
}
if (m_nodes[i].orientation)
{
absolutes[i] = m_nodes[i].orientation->Compute().q;
}
else if (pParent)
{
Quat relative = pParent->pose.q.GetInverted() * pNode->pose.q;
absolutes[i] = absolutes[pNode->parent] * relative;
}
}
for (uint32 i = 0; i < outputCount; ++i)
{
CHierarchy::SNode* pNode = m_hierarchy.GetNode(i);
if (!pNode)
{
continue;
}
CHierarchy::SNode* pParent = pNode->parent < 0 ?
nullptr : m_hierarchy.GetNode(pNode->parent);
if (!pParent)
{
pResult[i].q = absolutes[i];
continue;
}
pResult[i].q = absolutes[i];
if (!m_nodes[i].position)
{
pResult[i].t = pResult[pNode->parent].t +
pResult[i].t * absolutes[pNode->parent].GetInverted();
}
}
}
//
bool CMapper::NodeHasLocation(uint32 index)
{
if (CMapperOperator* pOperator = m_nodes[index].position)
{
if (pOperator->IsOfClass("Location"))
{
return true;
}
if (pOperator->HasLinksOfClass("Location"))
{
return true;
}
}
if (CMapperOperator* pOperator = m_nodes[index].orientation)
{
if (pOperator->IsOfClass("Location"))
{
return true;
}
if (pOperator->HasLinksOfClass("Location"))
{
return true;
}
}
return false;
}
void CMapper::GetChildrenIndices(uint32 parent, std::vector<uint32>& children)
{
uint32 nodeCount = m_hierarchy.GetNodeCount();
for (uint32 i = 0; i < nodeCount; ++i)
{
if (m_hierarchy.GetNode(i)->parent != parent)
{
continue;
}
children.push_back(i);
}
}
bool CMapper::ChildrenHaveLocation(uint32 index)
{
std::vector<uint32> children;
GetChildrenIndices(index, children);
uint32 childrenCount = uint32(children.size());
for (uint32 i = 0; i < childrenCount; ++i)
{
if (ChildrenHaveLocation(children[i]))
{
return true;
}
}
return false;
}
bool CMapper::NodeOrChildrenHaveLocation(uint32 index)
{
if (NodeHasLocation(index))
{
return true;
}
std::vector<uint32> children;
GetChildrenIndices(index, children);
uint32 childrenCount = uint32(children.size());
for (uint32 i = 0; i < childrenCount; ++i)
{
if (NodeOrChildrenHaveLocation(children[i]))
{
return true;
}
}
return false;
}
bool CMapper::SerializeTo(XmlNodeRef& node)
{
XmlNodeRef hierarchy = node->newChild("Hierarchy");
uint32 nodeCount = GetNodeCount();
std::vector<IXmlNode*> nodes(nodeCount);
for (uint32 i = 0; i < nodeCount; ++i)
{
if (!NodeOrChildrenHaveLocation(i))
{
continue;
}
CHierarchy::SNode* pNode = m_hierarchy.GetNode(i);
if (!pNode)
{
return false;
}
XmlNodeRef xmlParent = hierarchy;
int32 parent = pNode->parent;
if (parent > -1)
{
xmlParent = nodes[parent];
}
nodes[i] = xmlParent->newChild("Node");
nodes[i]->setAttr("name", pNode->name);
if (CMapperOperator* pOperator = m_nodes[i].position)
{
XmlNodeRef position = nodes[i]->newChild("Position");
XmlNodeRef child = position->newChild("Operator");
if (!pOperator->SerializeWithLinksTo(child))
{
return false;
}
}
if (CMapperOperator* pOperator = m_nodes[i].orientation)
{
XmlNodeRef orientation = nodes[i]->newChild("Orientation");
XmlNodeRef child = orientation->newChild("Operator");
if (!pOperator->SerializeWithLinksTo(child))
{
return false;
}
}
}
return true;
}
bool CMapper::SerializeFrom(XmlNodeRef& node, int32 parent)
{
int childCount = uint32(node->getChildCount());
for (int i = 0; i < childCount; ++i)
{
XmlNodeRef child = node->getChild(i);
if (::_stricmp(child->getTag(), "Node"))
{
continue;
}
uint32 index = m_hierarchy.AddNode(child->getAttr("name"), QuatT(IDENTITY), parent);
if (!SerializeFrom(child, int32(index)))
{
return false;
}
}
return true;
}
bool CMapper::SerializeFrom(XmlNodeRef& node)
{
XmlNodeRef hierarchy = node->findChild("Hierarchy");
if (!hierarchy)
{
return false;
}
m_hierarchy.ClearNodes();
if (!SerializeFrom(hierarchy, -1))
{
return false;
}
m_nodes.resize(m_hierarchy.GetNodeCount());
return true;
}
Code/Editor/Animation/SkeletonMapper.h
-76
View File
@@ -1,76 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPER_H
#define CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPER_H
#pragma once
#include "SkeletonHierarchy.h"
#include "SkeletonMapperOperator.h"
namespace Skeleton {
class CMapper
{
public:
struct SNode
{
_smart_ptr<CMapperOperator> position;
_smart_ptr<CMapperOperator> orientation;
};
public:
CMapper();
~CMapper();
public:
CHierarchy& GetHierarchy() { return m_hierarchy; }
void CreateFromHierarchy();
uint32 GetNodeCount() const { return uint32(m_nodes.size()); }
SNode* GetNode(uint32 index) { return &m_nodes[index]; }
const SNode* GetNode(uint32 index) const { return &m_nodes[index]; }
uint32 CreateLocation(const char* name);
void ClearLocations();
int32 FindLocation(const char* name) const;
uint32 GetLocationCount() const { return uint32(m_locations.size()); }
void SetLocation(CMapperLocation& location);
CMapperLocation* GetLocation(uint32 index) { return m_locations[index]; }
const CMapperLocation* GetLocation(uint32 index) const { return m_locations[index]; }
bool CreateLocationsHierarchy(CHierarchy& hierarchy);
void Map(QuatT* pResult);
bool SerializeTo(XmlNodeRef& node);
bool SerializeFrom(XmlNodeRef& node);
private:
bool NodeHasLocation(uint32 index);
bool ChildrenHaveLocation(uint32 index);
bool NodeOrChildrenHaveLocation(uint32 index);
bool SerializeFrom(XmlNodeRef& node, int32 parent);
bool CreateLocationsHierarchy(uint32 index, CHierarchy& hierarchy, int32 hierarchyParent = -1);
// TEMP
void GetChildrenIndices(uint32 parent, std::vector<uint32>& children);
private:
CHierarchy m_hierarchy;
std::vector<_smart_ptr<CMapperLocation> > m_locations;
std::vector<SNode> m_nodes;
};
} // namespace Skeleton
#endif // CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPER_H
Code/Editor/Animation/SkeletonMapperOperator.cpp
-284
View File
@@ -1,284 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "SkeletonMapperOperator.h"
using namespace Skeleton;
/*
CMapperOperatorDesc
*/
std::vector<CMapperOperatorDesc*> CMapperOperatorDesc::s_descs;
//
CMapperOperatorDesc::CMapperOperatorDesc(const char* name)
{
s_descs.push_back(this);
}
/*
CMapperOperator
*/
CMapperOperator::CMapperOperator(const char* className, uint32 positionCount, uint32 orientationCount)
{
m_className = className;
m_position.resize(positionCount, nullptr);
m_orientation.resize(orientationCount, nullptr);
}
CMapperOperator::~CMapperOperator()
{
}
//
bool CMapperOperator::IsOfClass(const char* className)
{
if (::_stricmp(m_className, className))
{
return false;
}
return true;
}
uint32 CMapperOperator::HasLinksOfClass(const char* className)
{
uint32 count = 0;
uint32 positionCount = m_position.size();
for (uint32 i = 0; i < positionCount; ++i)
{
CMapperOperator* pOperator = m_position[i];
if (!pOperator)
{
continue;
}
if (pOperator->IsOfClass(className))
{
++count;
}
}
uint32 orientationCount = m_orientation.size();
for (uint32 i = 0; i < orientationCount; ++i)
{
CMapperOperator* pOperator = m_orientation[i];
if (!pOperator)
{
continue;
}
if (pOperator->IsOfClass(className))
{
++count;
}
}
return count;
}
//
bool CMapperOperator::SerializeTo(XmlNodeRef& node)
{
node->setAttr("class", m_className);
uint32 parameterCount = uint32(m_parameters.size());
for (uint32 i = 0; i < parameterCount; ++i)
{
m_parameters[i]->Serialize(node, false);
}
return true;
}
bool CMapperOperator::SerializeFrom(XmlNodeRef& node)
{
uint32 parameterCount = uint32(m_parameters.size());
for (uint32 i = 0; i < parameterCount; ++i)
{
m_parameters[i]->Serialize(node, true);
}
return true;
}
bool CMapperOperator::SerializeWithLinksTo(XmlNodeRef& node)
{
if (!SerializeTo(node))
{
return false;
}
uint32 positionCount = uint32(m_position.size());
for (uint32 i = 0; i < positionCount; ++i)
{
CMapperOperator* pOperator = m_position[i];
if (!pOperator)
{
continue;
}
XmlNodeRef position = node->newChild("Position");
position->setAttr("index", i);
XmlNodeRef child = position->newChild("Operator");
if (!pOperator->SerializeWithLinksTo(child))
{
return false;
}
}
uint32 orientationCount = uint32(m_orientation.size());
for (uint32 i = 0; i < orientationCount; ++i)
{
CMapperOperator* pOperator = m_orientation[i];
if (!pOperator)
{
continue;
}
XmlNodeRef orientation = node->newChild("Orientation");
orientation->setAttr("index", i);
XmlNodeRef child = orientation->newChild("Operator");
if (!pOperator->SerializeWithLinksTo(child))
{
return false;
}
}
return true;
}
bool CMapperOperator::SerializeWithLinksFrom(XmlNodeRef& node)
{
if (!SerializeFrom(node))
{
return false;
}
return true;
}
/*
CMapperOperator_Transform
*/
class CMapperOperator_Transform
: public CMapperOperator
{
public:
CMapperOperator_Transform()
: CMapperOperator("Transform", 1, 1)
{
m_pAngles = new CVariable<Vec3>();
m_pAngles->SetName("rotation");
m_pAngles->Set(Vec3(0.0f, 0.0f, 0.0f));
m_pAngles->SetLimits(-180.0f, 180.0f);
AddParameter(*m_pAngles);
m_pVector = new CVariable<Vec3>();
m_pVector->SetName("vector");
m_pVector->Set(Vec3(0.0f, 0.0f, 0.0f));
AddParameter(*m_pVector);
m_pScale = new CVariable<Vec3>();
m_pScale->SetName("scale");
m_pScale->Set(Vec3(1.0f, 1.0f, 1.0f));
AddParameter(*m_pScale);
}
// CMapperOperator
public:
virtual QuatT CMapperOperator_Transform::Compute()
{
QuatT result(IDENTITY);
m_pVector->Get(result.t);
Vec3 scale;
m_pScale->Get(scale);
Vec3 angles;
m_pAngles->Get(angles);
result.q = Quat::CreateRotationXYZ(
Ang3(DEG2RAD(angles.x), DEG2RAD(angles.y), DEG2RAD(angles.z)));
if (CMapperOperator* pOperator = GetPosition(0))
{
result.t = pOperator->Compute().t.CompMul(scale) + result.t;
}
if (CMapperOperator* pOperator = GetOrientation(0))
{
result.q = pOperator->Compute().q * result.q;
}
return result;
}
private:
CVariable<Vec3>* m_pVector;
CVariable<Vec3>* m_pAngles;
CVariable<Vec3>* m_pScale;
};
SkeletonMapperOperatorRegister(Transform, CMapperOperator_Transform)
class CMapperOperator_PositionsToOrientation
: public CMapperOperator
{
public:
CMapperOperator_PositionsToOrientation()
: CMapperOperator("PositionsToOrientation", 3, 0)
{
}
// CMapperOperator
public:
virtual QuatT Compute()
{
CMapperOperator* pOperator0 = GetPosition(0);
CMapperOperator* pOperator1 = GetPosition(1);
CMapperOperator* pOperator2 = GetPosition(2);
if (!pOperator0 || !pOperator1 || !pOperator2)
{
return QuatT(IDENTITY);
}
Vec3 p0 = pOperator0->Compute().t;
Vec3 p1 = pOperator1->Compute().t;
Vec3 p2 = pOperator2->Compute().t;
Vec3 m = (p1 + p2) * 0.5f;
Vec3 y = (m - p0).GetNormalized();
Vec3 z = (p1 - p2).GetNormalized();
Vec3 x = y % z;
z = x % y;
Matrix33 m33;
m33.SetFromVectors(x, y, z);
QuatT result(IDENTITY);
result.q = Quat(m33);
return result;
}
};
SkeletonMapperOperatorRegister(PositionsToOrientation, CMapperOperator_PositionsToOrientation)
Code/Editor/Animation/SkeletonMapperOperator.h
-164
View File
@@ -1,164 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPEROPERATOR_H
#define CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPEROPERATOR_H
#pragma once
#include "../Util/Variable.h"
#undef GetClassName
#define SkeletonMapperOperatorRegister(name, className) \
class CMapperOperatorDesc_##name \
: public CMapperOperatorDesc \
{ \
public: \
CMapperOperatorDesc_##name() \
: CMapperOperatorDesc(#name) { } \
protected: \
virtual const char* GetName() { return #name; } \
virtual CMapperOperator* Create() { return new className(); } \
} mapperOperatorDesc__##name;
namespace Skeleton {
class CMapperOperator;
class CMapperOperatorDesc
{
public:
static uint32 GetCount() { return uint32(s_descs.size()); }
static const char* GetName(uint32 index) { return s_descs[index]->GetName(); }
static CMapperOperator* Create(uint32 index) { return s_descs[index]->Create(); }
private:
static std::vector<CMapperOperatorDesc*> s_descs;
public:
CMapperOperatorDesc(const char* name);
protected:
virtual const char* GetName() = 0;
virtual CMapperOperator* Create() = 0;
};
class CMapperOperator
: public _reference_target_t
{
protected:
CMapperOperator(const char* className, uint32 positionCount, uint32 orientationCount);
~CMapperOperator();
public:
const char* GetClassName() { return m_className; }
uint32 GetPositionCount() const { return uint32(m_position.size()); }
void SetPosition(uint32 index, CMapperOperator* pOperator) { m_position[index] = pOperator; }
CMapperOperator* GetPosition(uint32 index) { return m_position[index]; }
uint32 GetOrientationCount() const { return uint32(m_orientation.size()); }
void SetOrientation(uint32 index, CMapperOperator* pOperator) { m_orientation[index] = pOperator; }
CMapperOperator* GetOrientation(uint32 index) { return m_orientation[index]; }
uint32 GetParameterCount() { return uint32(m_parameters.size()); }
IVariable* GetParameter(uint32 index) { return m_parameters[index]; }
bool IsOfClass(const char* className);
uint32 HasLinksOfClass(const char* className);
bool SerializeTo(XmlNodeRef& node);
bool SerializeFrom(XmlNodeRef& node);
bool SerializeWithLinksTo(XmlNodeRef& node);
bool SerializeWithLinksFrom(XmlNodeRef& node);
protected:
void AddParameter(IVariable& variable) { m_parameters.push_back(&variable); }
public:
virtual QuatT Compute() = 0;
private:
const char* m_className;
std::vector<_smart_ptr<CMapperOperator> > m_position;
std::vector<_smart_ptr<CMapperOperator> > m_orientation;
std::vector<IVariablePtr> m_parameters;
};
class CMapperLocation
: public CMapperOperator
{
public:
CMapperLocation()
: CMapperOperator("Location", 0, 0)
{
m_pName = new CVariable<CString>();
m_pName->SetName("name");
m_pName->SetFlags(m_pName->GetFlags() | IVariable::UI_INVISIBLE);
AddParameter(*m_pName);
m_pAxis = new CVariable<Vec3>();
m_pAxis->SetName("axis");
m_pAxis->SetLimits(-3.0f, +3.0f);
m_pAxis->Set(Vec3(1.0f, 2.0f, 3.0f));
AddParameter(*m_pAxis);
m_location = QuatT(IDENTITY);
}
public:
void SetName(const char* name) { m_pName->Set(name); }
CString GetName() const { CString s; m_pName->Get(s); return s; }
void SetLocation(const QuatT& location) { m_location = location; }
const QuatT& GetLocation() const { return m_location; }
// CMapperOperator
public:
virtual QuatT Compute()
{
Vec3 axis;
m_pAxis->Get(axis);
uint32 x = fabs_tpl(axis.x);
uint32 y = fabs_tpl(axis.y);
uint32 z = fabs_tpl(axis.z);
if (x < 1 || y < 1 || z < 1 ||
x > 3 || y > 3 || y > 3 ||
x == y || x == z || y == z)
{
return QuatT(IDENTITY);
}
Matrix33 matrix;
matrix.SetFromVectors(
m_location.q.GetColumn(x - 1) * f32(::sgn(axis.x)),
m_location.q.GetColumn(y - 1) * f32(::sgn(axis.y)),
m_location.q.GetColumn(z - 1) * f32(::sgn(axis.z)));
if (!matrix.IsOrthonormalRH(0.01f))
{
return QuatT(IDENTITY);
}
QuatT result = m_location;
result.q = Quat(matrix);
return result;
}
private:
CVariable<CString>* m_pName;
CVariable<Vec3>* m_pAxis;
QuatT m_location;
};
} // namespace Skeleton
#endif // CRYINCLUDE_EDITOR_ANIMATION_SKELETONMAPPEROPERATOR_H
Code/Editor/BaseLibrary.cpp
+1 -2
View File
@@ -258,9 +258,8 @@ bool CBaseLibrary::SaveLibrary(const char* name, bool saveEmptyLibrary)
}
if (!bRes)
{
string strMessage;
QByteArray filenameUtf8 = fileName.toUtf8();
strMessage.Format("The file %s is read-only and the save of the library couldn't be performed. Try to remove the \"read-only\" flag or check-out the file and then try again.", filenameUtf8.data());
AZStd::string strMessage = AZStd::string::format("The file %s is read-only and the save of the library couldn't be performed. Try to remove the \"read-only\" flag or check-out the file and then try again.", filenameUtf8.data());
CryMessageBox(strMessage.c_str(), "Saving Error", MB_OK | MB_ICONWARNING);
}
return bRes;
Code/Editor/BaseLibraryManager.cpp
+3 -3
View File
@@ -526,7 +526,7 @@ void CBaseLibraryManager::Serialize(XmlNodeRef& node, bool bLoading)
QString CBaseLibraryManager::MakeUniqueItemName(const QString& srcName, const QString& libName)
{
// unlikely we'll ever encounter more than 16
std::vector<string> possibleDuplicates;
std::vector<AZStd::string> possibleDuplicates;
possibleDuplicates.reserve(16);
// search for strings in the database that might have a similar name (ignore case)
@@ -550,7 +550,7 @@ QString CBaseLibraryManager::MakeUniqueItemName(const QString& srcName, const QS
const QString& name = pItem->GetName();
if (name.startsWith(srcName, Qt::CaseInsensitive))
{
possibleDuplicates.push_back(string(name.toUtf8().data()));
possibleDuplicates.push_back(AZStd::string(name.toUtf8().data()));
}
}
pEnum->Release();
@@ -560,7 +560,7 @@ QString CBaseLibraryManager::MakeUniqueItemName(const QString& srcName, const QS
return srcName;
}
std::sort(possibleDuplicates.begin(), possibleDuplicates.end(), [](const string& strOne, const string& strTwo)
std::sort(possibleDuplicates.begin(), possibleDuplicates.end(), [](const AZStd::string& strOne, const AZStd::string& strTwo)
{
// I can assume size sorting since if the length is different, either one of the two strings doesn't
// closely match the string we are trying to duplicate, or it's a bigger number (X1 vs X10)
Code/Editor/Commands/CommandManager.cpp
+35 -36
View File
@@ -79,9 +79,9 @@ CEditorCommandManager::~CEditorCommandManager()
m_uiCommands.clear();
}
string CEditorCommandManager::GetFullCommandName(const string& module, const string& name)
AZStd::string CEditorCommandManager::GetFullCommandName(const AZStd::string& module, const AZStd::string& name)
{
string fullName = module;
AZStd::string fullName = module;
fullName += ".";
fullName += name;
return fullName;
@@ -91,10 +91,10 @@ bool CEditorCommandManager::AddCommand(CCommand* pCommand, TPfnDeleter deleter)
{
assert(pCommand);
string module = pCommand->GetModule();
string name = pCommand->GetName();
AZStd::string module = pCommand->GetModule();
AZStd::string name = pCommand->GetName();
if (IsRegistered(module, name) && m_bWarnDuplicate)
if (IsRegistered(module.c_str(), name.c_str()) && m_bWarnDuplicate)
{
QString errMsg;
@@ -118,7 +118,7 @@ bool CEditorCommandManager::AddCommand(CCommand* pCommand, TPfnDeleter deleter)
bool CEditorCommandManager::UnregisterCommand(const char* module, const char* name)
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
CommandTable::iterator itr = m_commands.find(fullName);
if (itr != m_commands.end())
@@ -154,7 +154,7 @@ bool CEditorCommandManager::RegisterUICommand(
return false;
}
return AttachUIInfo(GetFullCommandName(module, name), uiInfo);
return AttachUIInfo(GetFullCommandName(module, name).c_str(), uiInfo);
}
bool CEditorCommandManager::AttachUIInfo(const char* fullCmdName, const CCommand0::SUIInfo& uiInfo)
@@ -190,14 +190,14 @@ bool CEditorCommandManager::AttachUIInfo(const char* fullCmdName, const CCommand
return true;
}
bool CEditorCommandManager::GetUIInfo(const string& module, const string& name, CCommand0::SUIInfo& uiInfo) const
bool CEditorCommandManager::GetUIInfo(const AZStd::string& module, const AZStd::string& name, CCommand0::SUIInfo& uiInfo) const
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
return GetUIInfo(fullName, uiInfo);
}
bool CEditorCommandManager::GetUIInfo(const string& fullCmdName, CCommand0::SUIInfo& uiInfo) const
bool CEditorCommandManager::GetUIInfo(const AZStd::string& fullCmdName, CCommand0::SUIInfo& uiInfo) const
{
CommandTable::const_iterator iter = m_commands.find(fullCmdName);
@@ -223,9 +223,9 @@ int CEditorCommandManager::GenNewCommandId()
return uniqueId++;
}
QString CEditorCommandManager::Execute(const string& module, const string& name, const CCommand::CArgs& args)
QString CEditorCommandManager::Execute(const AZStd::string& module, const AZStd::string& name, const CCommand::CArgs& args)
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
CommandTable::iterator iter = m_commands.find(fullName);
if (iter != m_commands.end())
@@ -245,18 +245,18 @@ QString CEditorCommandManager::Execute(const string& module, const string& name,
return "";
}
QString CEditorCommandManager::Execute(const string& cmdLine)
QString CEditorCommandManager::Execute(const AZStd::string& cmdLine)
{
string cmdTxt, argsTxt;
AZStd::string cmdTxt, argsTxt;
size_t argStart = cmdLine.find_first_of(' ');
cmdTxt = cmdLine.substr(0, argStart);
argsTxt = "";
if (argStart != string::npos)
if (argStart != AZStd::string::npos)
{
argsTxt = cmdLine.substr(argStart + 1);
argsTxt.Trim();
AZ::StringFunc::TrimWhiteSpace(argsTxt, true, true);
}
CommandTable::iterator itr = m_commands.find(cmdTxt);
@@ -301,7 +301,7 @@ void CEditorCommandManager::Execute(int commandId)
}
}
void CEditorCommandManager::GetCommandList(std::vector<string>& cmds) const
void CEditorCommandManager::GetCommandList(std::vector<AZStd::string>& cmds) const
{
cmds.clear();
cmds.reserve(m_commands.size());
@@ -315,9 +315,9 @@ void CEditorCommandManager::GetCommandList(std::vector<string>& cmds) const
std::sort(cmds.begin(), cmds.end());
}
string CEditorCommandManager::AutoComplete(const string& substr) const
AZStd::string CEditorCommandManager::AutoComplete(const AZStd::string& substr) const
{
std::vector<string> cmds;
std::vector<AZStd::string> cmds;
GetCommandList(cmds);
// If substring is empty return first command.
@@ -358,7 +358,7 @@ string CEditorCommandManager::AutoComplete(const string& substr) const
bool CEditorCommandManager::IsRegistered(const char* module, const char* name) const
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
CommandTable::const_iterator iter = m_commands.find(fullName);
if (iter != m_commands.end())
@@ -373,7 +373,7 @@ bool CEditorCommandManager::IsRegistered(const char* module, const char* name) c
bool CEditorCommandManager::IsRegistered(const char* cmdLine_) const
{
string cmdTxt, argsTxt, cmdLine(cmdLine_);
AZStd::string cmdTxt, argsTxt, cmdLine(cmdLine_);
size_t argStart = cmdLine.find_first_of(' ');
cmdTxt = cmdLine.substr(0, argStart);
CommandTable::const_iterator iter = m_commands.find(cmdTxt);
@@ -402,9 +402,9 @@ bool CEditorCommandManager::IsRegistered(int commandId) const
return false;
}
void CEditorCommandManager::SetCommandAvailableInScripting(const string& module, const string& name)
void CEditorCommandManager::SetCommandAvailableInScripting(const AZStd::string& module, const AZStd::string& name)
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
CommandTable::iterator iter = m_commands.find(fullName);
if (iter != m_commands.end())
@@ -413,7 +413,7 @@ void CEditorCommandManager::SetCommandAvailableInScripting(const string& module,
}
}
bool CEditorCommandManager::IsCommandAvailableInScripting(const string& fullCmdName) const
bool CEditorCommandManager::IsCommandAvailableInScripting(const AZStd::string& fullCmdName) const
{
CommandTable::const_iterator iter = m_commands.find(fullCmdName);
@@ -425,16 +425,16 @@ bool CEditorCommandManager::IsCommandAvailableInScripting(const string& fullCmdN
return false;
}
bool CEditorCommandManager::IsCommandAvailableInScripting(const string& module, const string& name) const
bool CEditorCommandManager::IsCommandAvailableInScripting(const AZStd::string& module, const AZStd::string& name) const
{
string fullName = GetFullCommandName(module, name);
AZStd::string fullName = GetFullCommandName(module, name);
return IsCommandAvailableInScripting(fullName);
}
void CEditorCommandManager::LogCommand(const string& fullCmdName, const CCommand::CArgs& args) const
void CEditorCommandManager::LogCommand(const AZStd::string& fullCmdName, const CCommand::CArgs& args) const
{
string cmdLine = fullCmdName;
AZStd::string cmdLine = fullCmdName;
for (int i = 0; i < args.GetArgCount(); ++i)
{
@@ -509,7 +509,7 @@ void CEditorCommandManager::LogCommand(const string& fullCmdName, const CCommand
if (pScriptTermDialog)
{
string text = "> ";
AZStd::string text = "> ";
text += cmdLine;
text += "\r\n";
pScriptTermDialog->AppendText(text.c_str());
@@ -526,14 +526,14 @@ QString CEditorCommandManager::ExecuteAndLogReturn(CCommand* pCommand, const CCo
return result;
}
void CEditorCommandManager::GetArgsFromString(const string& argsTxt, CCommand::CArgs& argList)
void CEditorCommandManager::GetArgsFromString(const AZStd::string& argsTxt, CCommand::CArgs& argList)
{
const char quoteSymbol = '\'';
int curPos = 0;
int prevPos = 0;
string arg = argsTxt.Tokenize(" ", curPos);
while (!arg.empty())
AZStd::vector<AZStd::string> tokens;
AZ::StringFunc::Tokenize(argsTxt, tokens, ' ');
for(AZStd::string& arg : tokens)
{
if (arg[0] == quoteSymbol) // A special consideration for a quoted string
{
@@ -542,11 +542,11 @@ void CEditorCommandManager::GetArgsFromString(const string& argsTxt, CCommand::C
size_t openingQuotePos = argsTxt.find(quoteSymbol, prevPos);
size_t closingQuotePos = argsTxt.find(quoteSymbol, curPos);
if (closingQuotePos != string::npos)
if (closingQuotePos != AZStd::string::npos)
{
arg = argsTxt.substr(openingQuotePos + 1, closingQuotePos - openingQuotePos - 1);
size_t nextArgPos = argsTxt.find(' ', closingQuotePos + 1);
curPos = nextArgPos != string::npos ? nextArgPos + 1 : argsTxt.length();
curPos = nextArgPos != AZStd::string::npos ? nextArgPos + 1 : argsTxt.length();
for (; curPos < argsTxt.length(); ++curPos) // Skip spaces.
{
@@ -565,6 +565,5 @@ void CEditorCommandManager::GetArgsFromString(const string& argsTxt, CCommand::C
argList.Add(arg.c_str());
prevPos = curPos;
arg = argsTxt.Tokenize(" ", curPos);
}
}
Code/Editor/Commands/CommandManager.h
+13 -13
View File
@@ -48,20 +48,20 @@ public:
const AZStd::function<void()>& functor,
const CCommand0::SUIInfo& uiInfo);
bool AttachUIInfo(const char* fullCmdName, const CCommand0::SUIInfo& uiInfo);
bool GetUIInfo(const string& module, const string& name, CCommand0::SUIInfo& uiInfo) const;
bool GetUIInfo(const string& fullCmdName, CCommand0::SUIInfo& uiInfo) const;
QString Execute(const string& cmdLine);
QString Execute(const string& module, const string& name, const CCommand::CArgs& args);
bool GetUIInfo(const AZStd::string& module, const AZStd::string& name, CCommand0::SUIInfo& uiInfo) const;
bool GetUIInfo(const AZStd::string& fullCmdName, CCommand0::SUIInfo& uiInfo) const;
QString Execute(const AZStd::string& cmdLine);
QString Execute(const AZStd::string& module, const AZStd::string& name, const CCommand::CArgs& args);
void Execute(int commandId);
void GetCommandList(std::vector<string>& cmds) const;
void GetCommandList(std::vector<AZStd::string>& cmds) const;
//! Used in the console dialog
string AutoComplete(const string& substr) const;
AZStd::string AutoComplete(const AZStd::string& substr) const;
bool IsRegistered(const char* module, const char* name) const;
bool IsRegistered(const char* cmdLine) const;
bool IsRegistered(int commandId) const;
void SetCommandAvailableInScripting(const string& module, const string& name);
bool IsCommandAvailableInScripting(const string& module, const string& name) const;
bool IsCommandAvailableInScripting(const string& fullCmdName) const;
void SetCommandAvailableInScripting(const AZStd::string& module, const AZStd::string& name);
bool IsCommandAvailableInScripting(const AZStd::string& module, const AZStd::string& name) const;
bool IsCommandAvailableInScripting(const AZStd::string& fullCmdName) const;
//! Turning off the warning is needed for reloading the ribbon bar.
void TurnDuplicateWarningOn() { m_bWarnDuplicate = true; }
void TurnDuplicateWarningOff() { m_bWarnDuplicate = false; }
@@ -74,7 +74,7 @@ protected:
};
//! A full command name to an actual command mapping
typedef std::map<string, SCommandTableEntry> CommandTable;
typedef std::map<AZStd::string, SCommandTableEntry> CommandTable;
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
CommandTable m_commands;
@@ -86,9 +86,9 @@ protected:
bool m_bWarnDuplicate;
static int GenNewCommandId();
static string GetFullCommandName(const string& module, const string& name);
static void GetArgsFromString(const string& argsTxt, CCommand::CArgs& argList);
void LogCommand(const string& fullCmdName, const CCommand::CArgs& args) const;
static AZStd::string GetFullCommandName(const AZStd::string& module, const AZStd::string& name);
static void GetArgsFromString(const AZStd::string& argsTxt, CCommand::CArgs& argList);
void LogCommand(const AZStd::string& fullCmdName, const CCommand::CArgs& args) const;
QString ExecuteAndLogReturn(CCommand* pCommand, const CCommand::CArgs& args);
};
Code/Editor/ConfigGroup.cpp
+3 -3
View File
@@ -127,9 +127,9 @@ namespace Config
case IConfigVar::eType_STRING:
{
string currentValue = nullptr;
AZStd::string currentValue;
var->Get(&currentValue);
node->setAttr(szName, currentValue);
node->setAttr(szName, currentValue.c_str());
break;
}
}
@@ -186,7 +186,7 @@ namespace Config
case IConfigVar::eType_STRING:
{
string currentValue = nullptr;
AZStd::string currentValue;
var->GetDefault(&currentValue);
QString readValue(currentValue.c_str());
if (node->getAttr(szName, readValue))
Code/Editor/ConfigGroup.h
+5 -5
View File
@@ -47,12 +47,12 @@ namespace Config
return m_type;
}
ILINE const string& GetName() const
ILINE const AZStd::string& GetName() const
{
return m_name;
}
ILINE const string& GetDescription() const
ILINE const AZStd::string& GetDescription() const
{
return m_description;
}
@@ -71,13 +71,13 @@ namespace Config
static EType TranslateType(const bool&) { return eType_BOOL; }
static EType TranslateType(const int&) { return eType_INT; }
static EType TranslateType(const float&) { return eType_FLOAT; }
static EType TranslateType(const string&) { return eType_STRING; }
static EType TranslateType(const AZStd::string&) { return eType_STRING; }
protected:
EType m_type;
uint8 m_flags;
string m_name;
string m_description;
AZStd::string m_name;
AZStd::string m_description;
void* m_ptr;
ICVar* m_pCVar;
};
Code/Editor/ControlMRU.cpp
-135
View File
@@ -1,135 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "ControlMRU.h"
IMPLEMENT_XTP_CONTROL(CControlMRU, CXTPControlRecentFileList)
bool CControlMRU::DoesFileExist(CString& sFileName)
{
return (_access(sFileName.GetBuffer(), 0) == 0);
}
void CControlMRU::OnCalcDynamicSize(DWORD dwMode)
{
CRecentFileList* pRecentFileList = GetRecentFileList();
if (!pRecentFileList)
{
return;
}
CString* pArrNames = pRecentFileList->m_arrNames;
assert(pArrNames != nullptr);
if (!pArrNames)
{
return;
}
while (m_nIndex + 1 < m_pControls->GetCount())
{
CXTPControl* pControl = m_pControls->GetAt(m_nIndex + 1);
assert(pControl);
if (pControl->GetID() >= GetFirstMruID()
&& pControl->GetID() <= GetFirstMruID() + pRecentFileList->m_nSize)
{
m_pControls->Remove(pControl);
}
else
{
break;
}
}
if (m_pParent->IsCustomizeMode())
{
m_dwHideFlags = 0;
SetEnabled(true);
return;
}
if (pArrNames[0].IsEmpty())
{
SetCaption(CString(MAKEINTRESOURCE(IDS_NORECENTFILE_CAPTION)));
SetDescription("No recently opened files");
m_dwHideFlags = 0;
SetEnabled(false);
return;
}
else
{
SetCaption(CString(MAKEINTRESOURCE(IDS_RECENTFILE_CAPTION)));
SetDescription("Open this document");
}
m_dwHideFlags |= xtpHideGeneric;
CString sCurDir = (Path::GetEditingGameDataFolder() + "\\").c_str();
int nCurDir = sCurDir.GetLength();
CString strName;
CString strTemp;
int iLastValidMRU = 0;
for (int iMRU = 0; iMRU < pRecentFileList->m_nSize; iMRU++)
{
if (!pRecentFileList->GetDisplayName(strName, iMRU, sCurDir.GetBuffer(), nCurDir))
{
break;
}
if (DoesFileExist(pArrNames[iMRU]))
{
CString sCurEntryDir = pArrNames[iMRU].Left(nCurDir);
if (sCurEntryDir.CompareNoCase(sCurDir) != 0)
{
//unavailable entry (wrong directory)
continue;
}
}
else
{
//invalid entry (not existing)
continue;
}
int nId = iMRU + GetFirstMruID();
CXTPControl* pControl = m_pControls->Add(xtpControlButton, nId, _T(""), m_nIndex + iLastValidMRU + 1, true);
assert(pControl);
pControl->SetCaption(CXTPControlWindowList::ConstructCaption(strName, iLastValidMRU + 1));
pControl->SetFlags(xtpFlagManualUpdate);
pControl->SetBeginGroup(iLastValidMRU == 0 && m_nIndex != 0);
pControl->SetParameter(pArrNames[iMRU]);
CString sDescription = "Open file: " + pArrNames[iMRU];
pControl->SetDescription(sDescription);
if ((GetFlags() & xtpFlagWrapRow) && iMRU == 0)
{
pControl->SetFlags(pControl->GetFlags() | xtpFlagWrapRow);
}
++iLastValidMRU;
}
//if no entry was valid, treat as none would exist
if (iLastValidMRU == 0)
{
SetCaption(CString(MAKEINTRESOURCE(IDS_NORECENTFILE_CAPTION)));
SetDescription("No recently opened files");
m_dwHideFlags = 0;
SetEnabled(false);
}
}
Code/Editor/ControlMRU.h
-24
View File
@@ -1,24 +0,0 @@
/*
* 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
*
*/
#pragma once
#ifndef CRYINCLUDE_EDITOR_CONTROLMRU_H
#define CRYINCLUDE_EDITOR_CONTROLMRU_H
class CControlMRU
: public CXTPControlRecentFileList
{
protected:
virtual void OnCalcDynamicSize(DWORD dwMode);
private:
DECLARE_XTP_CONTROL(CControlMRU)
bool DoesFileExist(CString& sFileName);
};
#endif // CRYINCLUDE_EDITOR_CONTROLMRU_H
Code/Editor/Controls/ConsoleSCB.cpp
+6 -6
View File
@@ -180,7 +180,7 @@ bool ConsoleLineEdit::event(QEvent* ev)
if (newStr.isEmpty())
{
newStr = GetIEditor()->GetCommandManager()->AutoComplete(cstring.toUtf8().data());
newStr = GetIEditor()->GetCommandManager()->AutoComplete(cstring.toUtf8().data()).c_str();
}
}
@@ -211,7 +211,7 @@ void ConsoleLineEdit::keyPressEvent(QKeyEvent* ev)
{
if (commandManager->IsRegistered(str.toUtf8().data()))
{
commandManager->Execute(QtUtil::ToString(str));
commandManager->Execute(str.toUtf8().data());
}
else
{
@@ -566,15 +566,15 @@ static void OnVariableUpdated([[maybe_unused]] int row, ICVar* pCVar)
static CVarBlock* VarBlockFromConsoleVars()
{
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
std::vector<const char*> cmds;
AZStd::vector<AZStd::string_view> cmds;
cmds.resize(console->GetNumVars());
size_t cmdCount = console->GetSortedVars(&cmds[0], cmds.size());
size_t cmdCount = console->GetSortedVars(cmds);
CVarBlock* vb = new CVarBlock;
IVariable* pVariable = nullptr;
for (int i = 0; i < cmdCount; i++)
{
ICVar* pCVar = console->GetCVar(cmds[i]);
ICVar* pCVar = console->GetCVar(cmds[i].data());
if (!pCVar)
{
continue;
@@ -606,7 +606,7 @@ static CVarBlock* VarBlockFromConsoleVars()
pCVar->AddOnChangeFunctor(onChange);
pVariable->SetDescription(pCVar->GetHelp());
pVariable->SetName(cmds[i]);
pVariable->SetName(cmds[i].data());
// Transfer the custom limits have they have been set for this variable
if (pCVar->HasCustomLimits())
Code/Editor/Controls/ConsoleSCBMFC.cpp
-543
View File
@@ -1,543 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "ConsoleSCBMFC.h"
#include "PropertiesDialog.h"
#include "QtViewPaneManager.h"
#include "Core/QtEditorApplication.h"
#include <Controls/ui_ConsoleSCBMFC.h>
#include <QtUtil.h>
#include <QtUtilWin.h>
#include <QtCore/QStringList>
#include <QtCore/QScopedPointer>
#include <QtCore/QPoint>
#include <QtGui/QCursor>
#include <QtGui/QMouseEvent>
#include <QtWidgets/QStyle>
#include <QtWidgets/QStyleFactory>
#include <QtWidgets/QMenu>
#include <QtWidgets/QScrollBar>
#include <QtWidgets/QVBoxLayout>
#include <vector>
#include <iostream>
namespace MFC
{
static CPropertiesDialog* gPropertiesDlg = nullptr;
static CString mfc_popup_helper(HWND hwnd, int x, int y);
static CConsoleSCB* s_consoleSCB = nullptr;
static QString RemoveColorCode(const QString& text, int& iColorCode)
{
QString cleanString;
cleanString.reserve(text.size());
const int textSize = text.size();
for (int i = 0; i < textSize; ++i)
{
QChar c = text.at(i);
bool isLast = i == textSize - 1;
if (c == '$' && !isLast && text.at(i + 1).isDigit())
{
if (iColorCode == 0)
{
iColorCode = text.at(i + 1).digitValue();
}
++i;
continue;
}
if (c == '\r' || c == '\n')
{
++i;
continue;
}
cleanString.append(c);
}
return cleanString;
}
ConsoleLineEdit::ConsoleLineEdit(QWidget* parent)
: QLineEdit(parent)
, m_historyIndex(0)
, m_bReusedHistory(false)
{
}
void ConsoleLineEdit::mousePressEvent(QMouseEvent* ev)
{
if (ev->type() == QEvent::MouseButtonPress && ev->button() & Qt::RightButton)
{
Q_EMIT variableEditorRequested();
}
QLineEdit::mousePressEvent(ev);
}
void ConsoleLineEdit::mouseDoubleClickEvent(QMouseEvent* ev)
{
Q_EMIT variableEditorRequested();
}
bool ConsoleLineEdit::event(QEvent* ev)
{
// Tab key doesn't go to keyPressEvent(), must be processed here
if (ev->type() != QEvent::KeyPress)
{
return QLineEdit::event(ev);
}
QKeyEvent* ke = static_cast<QKeyEvent*>(ev);
if (ke->key() != Qt::Key_Tab)
{
return QLineEdit::event(ev);
}
QString inputStr = text();
QString newStr;
QStringList tokens = inputStr.split(" ");
inputStr = tokens.isEmpty() ? QString() : tokens.first();
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
const bool ctrlPressed = ke->modifiers() & Qt::ControlModifier;
CString cstring = QtUtil::ToCString(inputStr); // TODO: Use QString once the backend stops using QString
if (ctrlPressed)
{
newStr = QtUtil::ToString(console->AutoCompletePrev(cstring));
}
else
{
newStr = QtUtil::ToString(console->ProcessCompletion(cstring));
newStr = QtUtil::ToString(console->AutoComplete(cstring));
if (newStr.isEmpty())
{
newStr = QtUtil::ToQString(GetIEditor()->GetCommandManager()->AutoComplete(QtUtil::ToString(newStr)));
}
}
if (!newStr.isEmpty())
{
newStr += " ";
setText(newStr);
}
deselect();
return true;
}
void ConsoleLineEdit::keyPressEvent(QKeyEvent* ev)
{
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
auto commandManager = GetIEditor()->GetCommandManager();
console->ResetAutoCompletion();
switch (ev->key())
{
case Qt::Key_Enter:
case Qt::Key_Return:
{
QString str = text().trimmed();
if (!str.isEmpty())
{
if (commandManager->IsRegistered(QtUtil::ToCString(str)))
{
commandManager->Execute(QtUtil::ToString(str));
}
else
{
CLogFile::WriteLine(QtUtil::ToCString(str));
GetIEditor()->GetSystem()->GetIConsole()->ExecuteString(QtUtil::ToCString(str));
}
// If a history command was reused directly via up arrow enter, do not reset history index
if (m_history.size() > 0 && m_historyIndex < m_history.size() && m_history[m_historyIndex] == str)
{
m_bReusedHistory = true;
}
else
{
m_historyIndex = m_history.size();
}
// Do not add the same string if it is the top of the stack, but allow duplicate entries otherwise
if (m_history.isEmpty() || m_history.back() != str)
{
m_history.push_back(str);
if (!m_bReusedHistory)
{
m_historyIndex = m_history.size();
}
}
}
else
{
m_historyIndex = m_history.size();
}
setText(QString());
break;
}
case Qt::Key_AsciiTilde: // ~
case Qt::Key_Agrave: // `
// disable log.
GetIEditor()->ShowConsole(false);
setText(QString());
m_historyIndex = m_history.size();
break;
case Qt::Key_Escape:
setText(QString());
m_historyIndex = m_history.size();
break;
case Qt::Key_Up:
DisplayHistory(false /*bForward*/);
break;
case Qt::Key_Down:
DisplayHistory(true /*bForward*/);
break;
default:
QLineEdit::keyPressEvent(ev);
}
}
void ConsoleLineEdit::DisplayHistory(bool bForward)
{
if (m_history.isEmpty())
{
return;
}
// Immediately after reusing a history entry, ensure up arrow re-displays command just used
if (!m_bReusedHistory || bForward)
{
m_historyIndex = static_cast<unsigned int>(clamp_tpl(static_cast<int>(m_historyIndex) + (bForward ? 1 : -1), 0, m_history.size() - 1));
}
m_bReusedHistory = false;
setText(m_history[m_historyIndex]);
}
ConsoleTextEdit::ConsoleTextEdit(QWidget* parent)
: QTextEdit(parent)
{
}
Lines CConsoleSCB::s_pendingLines;
CConsoleSCB::CConsoleSCB(QWidget* parent)
: QWidget(parent)
, ui(new Ui::ConsoleMFC())
, m_richEditTextLength(0)
, m_backgroundTheme(gSettings.consoleBackgroundColorTheme)
{
m_lines = s_pendingLines;
s_pendingLines.clear();
s_consoleSCB = this;
ui->setupUi(this);
setMinimumHeight(120);
// Setup the color table for the default (light) theme
m_colorTable << QColor(0, 0, 0)
<< QColor(0, 0, 0)
<< QColor(0, 0, 200) // blue
<< QColor(0, 200, 0) // green
<< QColor(200, 0, 0) // red
<< QColor(0, 200, 200) // cyan
<< QColor(128, 112, 0) // yellow
<< QColor(200, 0, 200) // red+blue
<< QColor(0x000080ff)
<< QColor(0x008f8f8f);
OnStyleSettingsChanged();
connect(ui->button, &QPushButton::clicked, this, &CConsoleSCB::showVariableEditor);
connect(ui->lineEdit, &MFC::ConsoleLineEdit::variableEditorRequested, this, &MFC::CConsoleSCB::showVariableEditor);
connect(Editor::EditorQtApplication::instance(), &Editor::EditorQtApplication::skinChanged, this, &MFC::CConsoleSCB::OnStyleSettingsChanged);
if (GetIEditor()->IsInConsolewMode())
{
// Attach / register edit box
//CLogFile::AttachEditBox(m_edit.GetSafeHwnd()); // FIXME
}
}
CConsoleSCB::~CConsoleSCB()
{
s_consoleSCB = nullptr;
delete gPropertiesDlg;
gPropertiesDlg = nullptr;
CLogFile::AttachEditBox(nullptr);
}
void CConsoleSCB::RegisterViewClass()
{
QtViewOptions opts;
opts.preferedDockingArea = Qt::BottomDockWidgetArea;
opts.isDeletable = false;
opts.isStandard = true;
opts.showInMenu = true;
opts.builtInActionId = ID_VIEW_CONSOLEWINDOW;
opts.sendViewPaneNameBackToAmazonAnalyticsServers = true;
RegisterQtViewPane<CConsoleSCB>(GetIEditor(), LyViewPane::Console, LyViewPane::CategoryTools, opts);
}
void CConsoleSCB::OnStyleSettingsChanged()
{
ui->button->setIcon(QIcon(QString(":/controls/img/cvar_dark.bmp")));
// Set the debug/warning text colors appropriately for the background theme
// (e.g. not have black text on black background)
QColor textColor = Qt::black;
m_backgroundTheme = gSettings.consoleBackgroundColorTheme;
if (m_backgroundTheme == SEditorSettings::ConsoleColorTheme::Dark)
{
textColor = Qt::white;
}
m_colorTable[0] = textColor;
m_colorTable[1] = textColor;
QColor bgColor;
if (!GetIEditor()->IsInConsolewMode() && CConsoleSCB::GetCreatedInstance() && m_backgroundTheme == SEditorSettings::ConsoleColorTheme::Dark)
{
bgColor = Qt::black;
}
else
{
bgColor = Qt::white;
}
ui->textEdit->setStyleSheet(QString("QTextEdit{ background: %1 }").arg(bgColor.name(QColor::HexRgb)));
// Clear out the console text when we change our background color since
// some of the previous text colors may not be appropriate for the
// new background color
ui->textEdit->clear();
}
void CConsoleSCB::showVariableEditor()
{
const QPoint cursorPos = QCursor::pos();
CString str = mfc_popup_helper(0, cursorPos.x(), cursorPos.y());
if (!str.IsEmpty())
{
ui->lineEdit->setText(QtUtil::ToQString(str));
}
}
void CConsoleSCB::SetInputFocus()
{
ui->lineEdit->setFocus();
ui->lineEdit->setText(QString());
}
void CConsoleSCB::AddToConsole(const QString& text, bool bNewLine)
{
m_lines.push_back({ text, bNewLine });
FlushText();
}
void CConsoleSCB::FlushText()
{
if (m_lines.empty())
{
return;
}
// Store our current cursor in case we need to restore it, and check if
// the user has scrolled the text edit away from the bottom
const QTextCursor oldCursor = ui->textEdit->textCursor();
QScrollBar* scrollBar = ui->textEdit->verticalScrollBar();
const int oldScrollValue = scrollBar->value();
bool scrolledOffBottom = oldScrollValue != scrollBar->maximum();
ui->textEdit->moveCursor(QTextCursor::End);
QTextCursor textCursor = ui->textEdit->textCursor();
while (!m_lines.empty())
{
ConsoleLine line = m_lines.front();
m_lines.pop_front();
int iColor = 0;
QString text = MFC::RemoveColorCode(line.text, iColor);
if (iColor < 0 || iColor >= m_colorTable.size())
{
iColor = 0;
}
if (line.newLine)
{
text = QtUtil::trimRight(text);
text = "\r\n" + text;
}
QTextCharFormat format;
const QColor color(m_colorTable[iColor]);
format.setForeground(color);
if (iColor != 0)
{
format.setFontWeight(QFont::Bold);
}
textCursor.setCharFormat(format);
textCursor.insertText(text);
}
// If the user has selected some text in the text edit area or has scrolled
// away from the bottom, then restore the previous cursor and keep the scroll
// bar in the same location
if (oldCursor.hasSelection() || scrolledOffBottom)
{
ui->textEdit->setTextCursor(oldCursor);
scrollBar->setValue(oldScrollValue);
}
// Otherwise scroll to the bottom so the latest text can be seen
else
{
scrollBar->setValue(scrollBar->maximum());
}
}
QSize CConsoleSCB::minimumSizeHint() const
{
return QSize(-1, -1);
}
QSize CConsoleSCB::sizeHint() const
{
return QSize(100, 100);
}
/** static */
void CConsoleSCB::AddToPendingLines(const QString& text, bool bNewLine)
{
s_pendingLines.push_back({ text, bNewLine });
}
static CVarBlock* VarBlockFromConsoleVars()
{
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
std::vector<const char*> cmds;
cmds.resize(console->GetNumVars());
size_t cmdCount = console->GetSortedVars(&cmds[0], cmds.size());
CVarBlock* vb = new CVarBlock;
IVariable* pVariable = 0;
for (int i = 0; i < cmdCount; i++)
{
ICVar* pCVar = console->GetCVar(cmds[i]);
if (!pCVar)
{
continue;
}
int varType = pCVar->GetType();
switch (varType)
{
case CVAR_INT:
pVariable = new CVariable<int>();
pVariable->Set(pCVar->GetIVal());
break;
case CVAR_FLOAT:
pVariable = new CVariable<float>();
pVariable->Set(pCVar->GetFVal());
break;
case CVAR_STRING:
pVariable = new CVariable<CString>();
pVariable->Set(pCVar->GetString());
break;
default:
assert(0);
}
pVariable->SetDescription(pCVar->GetHelp());
pVariable->SetName(cmds[i]);
if (pVariable)
{
vb->AddVariable(pVariable);
}
}
return vb;
}
static void OnConsoleVariableUpdated(IVariable* pVar)
{
if (!pVar)
{
return;
}
CString varName = pVar->GetName();
ICVar* pCVar = GetIEditor()->GetSystem()->GetIConsole()->GetCVar(varName);
if (!pCVar)
{
return;
}
if (pVar->GetType() == IVariable::INT)
{
int val;
pVar->Get(val);
pCVar->Set(val);
}
else if (pVar->GetType() == IVariable::FLOAT)
{
float val;
pVar->Get(val);
pCVar->Set(val);
}
else if (pVar->GetType() == IVariable::STRING)
{
CString val;
pVar->Get(val);
pCVar->Set(val);
}
}
static CString mfc_popup_helper(HWND hwnd, int x, int y)
{
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
TSmartPtr<CVarBlock> vb = VarBlockFromConsoleVars();
XmlNodeRef node;
if (!gPropertiesDlg)
{
gPropertiesDlg = new CPropertiesDialog("Console Variables", node, AfxGetMainWnd(), true);
}
if (!gPropertiesDlg->m_hWnd)
{
gPropertiesDlg->Create(CPropertiesDialog::IDD, AfxGetMainWnd());
gPropertiesDlg->SetUpdateCallback(AZStd::bind(OnConsoleVariableUpdated, AZStd::placeholders::_1));
}
gPropertiesDlg->ShowWindow(SW_SHOW);
gPropertiesDlg->BringWindowToTop();
gPropertiesDlg->GetPropertyCtrl()->AddVarBlock(vb);
return "";
}
CConsoleSCB* CConsoleSCB::GetCreatedInstance()
{
return s_consoleSCB;
}
} // namespace MFC
#include <Controls/moc_ConsoleSCBMFC.cpp>
Code/Editor/Controls/FolderTreeCtrl.cpp
+1 -1
View File
@@ -400,7 +400,7 @@ void CFolderTreeCtrl::RemoveEmptyFolderItems(const QString& folder)
void CFolderTreeCtrl::Edit(const QString& path)
{
CFileUtil::EditTextFile(QtUtil::ToString(path), 0, IFileUtil::FILE_TYPE_SCRIPT);
CFileUtil::EditTextFile(path.toUtf8().data(), 0, IFileUtil::FILE_TYPE_SCRIPT);
}
void CFolderTreeCtrl::ShowInExplorer(const QString& path)
Code/Editor/Controls/ReflectedPropertyControl/PropertyCtrl.cpp
-3
View File
@@ -10,7 +10,6 @@
// Editor
#include "PropertyCtrl.h"
#include "PropertyAnimationCtrl.h"
#include "PropertyResourceCtrl.h"
#include "PropertyGenericCtrl.h"
#include "PropertyMiscCtrl.h"
@@ -22,9 +21,7 @@ void RegisterReflectedVarHandlers()
if (!registered)
{
registered = true;
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew AnimationPropertyWidgetHandler());
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew FileResourceSelectorWidgetHandler());
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew ReverbPresetPropertyHandler());
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew SequencePropertyHandler());
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew SequenceIdPropertyHandler());
EBUS_EVENT(AzToolsFramework::PropertyTypeRegistrationMessages::Bus, RegisterPropertyType, aznew LocalStringPropertyHandler());
Code/Editor/Controls/ReflectedPropertyControl/PropertyGenericCtrl.cpp
+3 -11
View File
@@ -73,16 +73,6 @@ void GenericPopupPropertyEditor::SetPropertyType(PropertyType type)
m_propertyType = type;
}
void ReverbPresetPropertyEditor::onEditClicked()
{
CSelectEAXPresetDlg PresetDlg(this);
PresetDlg.SetCurrPreset(GetValue());
if (PresetDlg.exec() == QDialog::Accepted)
{
SetValue(PresetDlg.GetCurrPreset());
}
}
void SequencePropertyEditor::onEditClicked()
{
CSelectSequenceDialog gtDlg(this);
@@ -132,7 +122,9 @@ void LocalStringPropertyEditor::onEditClicked()
if (pMgr->GetLocalizedInfoByIndex(i, sInfo))
{
item.desc = tr("English Text:\r\n");
item.desc += QString::fromWCharArray(Unicode::Convert<wstring>(sInfo.sUtf8TranslatedText).c_str());
AZStd::wstring utf8TranslatedTextW;
AZStd::to_wstring(utf8TranslatedTextW, sInfo.sUtf8TranslatedText);
item.desc += QString::fromWCharArray(utf8TranslatedTextW.c_str());
item.name = sInfo.sKey;
items.push_back(item);
}
Code/Editor/Controls/ReflectedPropertyControl/PropertyGenericCtrl.h
-10
View File
@@ -96,15 +96,6 @@ public:
}
};
class ReverbPresetPropertyEditor
: public GenericPopupPropertyEditor
{
public:
ReverbPresetPropertyEditor(QWidget* pParent = nullptr)
: GenericPopupPropertyEditor(pParent){}
void onEditClicked() override;
};
class MissionObjPropertyEditor
: public GenericPopupPropertyEditor
{
@@ -155,7 +146,6 @@ public:
// So we use our own
#define CONST_AZ_CRC(name, value) AZ::u32(value)
using ReverbPresetPropertyHandler = GenericPopupWidgetHandler<ReverbPresetPropertyEditor, CONST_AZ_CRC("ePropertyReverbPreset", 0x51469f38)>;
using MissionObjPropertyHandler = GenericPopupWidgetHandler<MissionObjPropertyEditor, CONST_AZ_CRC("ePropertyMissionObj", 0x4a2d0dc8)>;
using SequencePropertyHandler = GenericPopupWidgetHandler<SequencePropertyEditor, CONST_AZ_CRC("ePropertySequence", 0xdd1c7d44)>;
using SequenceIdPropertyHandler = GenericPopupWidgetHandler<SequenceIdPropertyEditor, CONST_AZ_CRC("ePropertySequenceId", 0x05983dcc)>;
Code/Editor/Controls/ReflectedPropertyControl/PropertyResourceCtrl.cpp
+38 -40
View File
@@ -17,9 +17,9 @@
// AzToolsFramework
#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
#include <AzToolsFramework/API/ToolsApplicationAPI.h>
#include <AzToolsFramework/UI/PropertyEditor/PropertyAudioCtrl.h>
// Editor
#include "IResourceSelectorHost.h"
#include "Controls/QToolTipWidget.h"
#include "Controls/BitmapToolTip.h"
@@ -35,8 +35,8 @@ BrowseButton::BrowseButton(PropertyType type, QWidget* parent /*= nullptr*/)
void BrowseButton::SetPathAndEmit(const QString& path)
{
//only emit if path changes, except for ePropertyGeomCache. Old property control
if (path != m_path || m_propertyType == ePropertyGeomCache)
//only emit if path changes. Old property control
if (path != m_path)
{
m_path = path;
emit PathChanged(m_path);
@@ -78,21 +78,6 @@ private:
// Filters for texture.
selection = AssetSelectionModel::AssetGroupSelection("Texture");
}
else if (m_propertyType == ePropertyModel)
{
// Filters for models.
selection = AssetSelectionModel::AssetGroupSelection("Geometry");
}
else if (m_propertyType == ePropertyGeomCache)
{
// Filters for geom caches.
selection = AssetSelectionModel::AssetTypeSelection("Geom Cache");
}
else if (m_propertyType == ePropertyFile)
{
// Filters for files.
selection = AssetSelectionModel::AssetTypeSelection("File");
}
else
{
return;
@@ -106,14 +91,7 @@ private:
switch (m_propertyType)
{
case ePropertyTexture:
case ePropertyModel:
newPath.replace("\\\\", "/");
}
switch (m_propertyType)
{
case ePropertyTexture:
case ePropertyModel:
case ePropertyFile:
if (newPath.size() > MAX_PATH)
{
newPath.resize(MAX_PATH);
@@ -125,26 +103,51 @@ private:
}
};
class ResourceSelectorButton
class AudioControlSelectorButton
: public BrowseButton
{
public:
AZ_CLASS_ALLOCATOR(ResourceSelectorButton, AZ::SystemAllocator, 0);
AZ_CLASS_ALLOCATOR(AudioControlSelectorButton, AZ::SystemAllocator, 0);
ResourceSelectorButton(PropertyType type, QWidget* pParent = nullptr)
AudioControlSelectorButton(PropertyType type, QWidget* pParent = nullptr)
: BrowseButton(type, pParent)
{
setToolTip(tr("Select resource"));
setToolTip(tr("Select Audio Control"));
}
private:
void OnClicked() override
{
SResourceSelectorContext x;
x.parentWidget = this;
x.typeName = Prop::GetPropertyTypeToResourceType(m_propertyType);
QString newPath = GetIEditor()->GetResourceSelectorHost()->SelectResource(x, m_path);
SetPathAndEmit(newPath);
AZStd::string resourceResult;
auto ConvertLegacyAudioPropertyType = [](const PropertyType type) -> AzToolsFramework::AudioPropertyType
{
switch (type)
{
case ePropertyAudioTrigger:
return AzToolsFramework::AudioPropertyType::Trigger;
case ePropertyAudioRTPC:
return AzToolsFramework::AudioPropertyType::Rtpc;
case ePropertyAudioSwitch:
return AzToolsFramework::AudioPropertyType::Switch;
case ePropertyAudioSwitchState:
return AzToolsFramework::AudioPropertyType::SwitchState;
case ePropertyAudioEnvironment:
return AzToolsFramework::AudioPropertyType::Environment;
case ePropertyAudioPreloadRequest:
return AzToolsFramework::AudioPropertyType::Preload;
default:
return AzToolsFramework::AudioPropertyType::NumTypes;
}
};
auto propType = ConvertLegacyAudioPropertyType(m_propertyType);
if (propType != AzToolsFramework::AudioPropertyType::NumTypes)
{
AzToolsFramework::AudioControlSelectorRequestBus::EventResult(
resourceResult, propType, &AzToolsFramework::AudioControlSelectorRequestBus::Events::SelectResource,
AZStd::string_view{ m_path.toUtf8().constData() });
SetPathAndEmit(QString{ resourceResult.c_str() });
}
}
};
@@ -235,18 +238,13 @@ void FileResourceSelectorWidget::SetPropertyType(PropertyType type)
AddButton(new TextureEditButton);
m_previewToolTip.reset(new CBitmapToolTip);
break;
case ePropertyModel:
case ePropertyGeomCache:
case ePropertyAudioTrigger:
case ePropertyAudioSwitch:
case ePropertyAudioSwitchState:
case ePropertyAudioRTPC:
case ePropertyAudioEnvironment:
case ePropertyAudioPreloadRequest:
AddButton(new ResourceSelectorButton(type));
break;
case ePropertyFile:
AddButton(new FileBrowseButton(type));
AddButton(new AudioControlSelectorButton(type));
break;
default:
break;
Code/Editor/Controls/ReflectedPropertyControl/ReflectedPropertiesPanel.cpp
-93
View File
@@ -1,93 +0,0 @@
/*
* 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
*
*/
// Description : implementation file
#include "EditorDefs.h"
#include "ReflectedPropertiesPanel.h"
/////////////////////////////////////////////////////////////////////////////
// ReflectedPropertiesPanel dialog
ReflectedPropertiesPanel::ReflectedPropertiesPanel(QWidget* pParent)
: ReflectedPropertyControl(pParent)
{
}
//////////////////////////////////////////////////////////////////////////
void ReflectedPropertiesPanel::DeleteVars()
{
ClearVarBlock();
m_updateCallbacks.clear();
m_varBlock = nullptr;
}
//////////////////////////////////////////////////////////////////////////
void ReflectedPropertiesPanel::SetVarBlock(class CVarBlock* vb, ReflectedPropertyControl::UpdateVarCallback* updCallback, const char* category)
{
assert(vb);
m_varBlock = vb;
RemoveAllItems();
m_varBlock = vb;
AddVarBlock(m_varBlock, category);
SetUpdateCallback(AZStd::bind(&ReflectedPropertiesPanel::OnPropertyChanged, this, AZStd::placeholders::_1));
// When new object set all previous callbacks freed.
m_updateCallbacks.clear();
if (updCallback)
{
stl::push_back_unique(m_updateCallbacks, updCallback);
}
}
//////////////////////////////////////////////////////////////////////////
void ReflectedPropertiesPanel::AddVars(CVarBlock* vb, ReflectedPropertyControl::UpdateVarCallback* updCallback, const char* category)
{
assert(vb);
bool bNewBlock = false;
// Make a clone of properties.
if (!m_varBlock)
{
RemoveAllItems();
m_varBlock = vb->Clone(true);
AddVarBlock(m_varBlock, category);
bNewBlock = true;
}
m_varBlock->Wire(vb);
if (bNewBlock)
{
SetUpdateCallback(AZStd::bind(&ReflectedPropertiesPanel::OnPropertyChanged, this, AZStd::placeholders::_1));
// When new object set all previous callbacks freed.
m_updateCallbacks.clear();
}
if (updCallback)
{
stl::push_back_unique(m_updateCallbacks, updCallback);
}
}
void ReflectedPropertiesPanel::OnPropertyChanged(IVariable* pVar)
{
std::list<ReflectedPropertyControl::UpdateVarCallback*>::iterator iter;
for (iter = m_updateCallbacks.begin(); iter != m_updateCallbacks.end(); ++iter)
{
(*iter)->operator()(pVar);
}
}
Code/Editor/Controls/ReflectedPropertyControl/ReflectedPropertiesPanel.h
-46
View File
@@ -1,46 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_REFLECTEDPROPERTIESPANEL_H
#define CRYINCLUDE_EDITOR_REFLECTEDPROPERTIESPANEL_H
#pragma once
#include "Controls/ReflectedPropertyControl/ReflectedPropertyCtrl.h"
#include "Util/Variable.h"
/////////////////////////////////////////////////////////////////////////////
// ReflectedPropertiesPanel dialog
AZ_PUSH_DISABLE_DLL_EXPORT_BASECLASS_WARNING
//This class is a port of ReflectedPropertiesPanel to use the ReflectedPropertyControl
class SANDBOX_API ReflectedPropertiesPanel
: public ReflectedPropertyControl
{
AZ_POP_DISABLE_DLL_EXPORT_BASECLASS_WARNING
public:
ReflectedPropertiesPanel(QWidget* pParent = nullptr); // standard constructor
void DeleteVars();
void AddVars(class CVarBlock* vb, ReflectedPropertyControl::UpdateVarCallback* func = nullptr, const char* category = nullptr);
void SetVarBlock(class CVarBlock* vb, ReflectedPropertyControl::UpdateVarCallback* func = nullptr, const char* category = nullptr);
protected:
void OnPropertyChanged(IVariable* pVar);
protected:
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
TSmartPtr<CVarBlock> m_varBlock;
std::list<ReflectedPropertyControl::UpdateVarCallback*> m_updateCallbacks;
AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
};
#endif // CRYINCLUDE_EDITOR_REFLECTEDPROPERTIESPANEL_H
Code/Editor/Controls/ReflectedPropertyControl/ReflectedPropertyItem.cpp
-10
View File
@@ -255,9 +255,6 @@ void ReflectedPropertyItem::SetVariable(IVariable *var)
case ePropertySelection:
m_reflectedVarAdapter = new ReflectedVarEnumAdapter;
break;
case ePropertyAnimation:
m_reflectedVarAdapter = new ReflectedVarAnimationAdapter;
break;
case ePropertyColor:
m_reflectedVarAdapter = new ReflectedVarColorAdapter;
break;
@@ -265,7 +262,6 @@ void ReflectedPropertyItem::SetVariable(IVariable *var)
m_reflectedVarAdapter = new ReflectedVarUserAdapter;
break;
case ePropertyEquip:
case ePropertyReverbPreset:
case ePropertyGameToken:
case ePropertyMissionObj:
case ePropertySequence:
@@ -276,15 +272,12 @@ void ReflectedPropertyItem::SetVariable(IVariable *var)
m_reflectedVarAdapter = new ReflectedVarGenericPropertyAdapter(desc.m_type);
break;
case ePropertyTexture:
case ePropertyModel:
case ePropertyGeomCache:
case ePropertyAudioTrigger:
case ePropertyAudioSwitch:
case ePropertyAudioSwitchState:
case ePropertyAudioRTPC:
case ePropertyAudioEnvironment:
case ePropertyAudioPreloadRequest:
case ePropertyFile:
m_reflectedVarAdapter = new ReflectedVarResourceAdapter;
break;
case ePropertyFloatCurve:
@@ -569,7 +562,6 @@ void ReflectedPropertyItem::SetValue(const QString& sValue, bool bRecordUndo, bo
break;
case ePropertyTexture:
case ePropertyModel:
value.replace('\\', '/');
break;
}
@@ -578,8 +570,6 @@ void ReflectedPropertyItem::SetValue(const QString& sValue, bool bRecordUndo, bo
switch (m_type)
{
case ePropertyTexture:
case ePropertyModel:
case ePropertyFile:
if (value.length() >= MAX_PATH)
{
value = value.left(MAX_PATH);
Code/Editor/Controls/ReflectedPropertyControl/ReflectedVar.cpp
-14
View File
@@ -31,12 +31,6 @@ void ReflectedVarInit::setupReflection(AZ::SerializeContext* serializeContext)
->Field("description", &CReflectedVar::m_description)
->Field("varName", &CReflectedVar::m_varName);
serializeContext->Class <CReflectedVarAnimation, CReflectedVar >()
->Version(1)
->Field("animation", &CReflectedVarAnimation::m_animation)
->Field("entityID", &CReflectedVarAnimation::m_entityID)
;
serializeContext->Class <CReflectedVarResource, CReflectedVar >()
->Version(1)
->Field("path", &CReflectedVarResource::m_path)
@@ -76,12 +70,6 @@ void ReflectedVarInit::setupReflection(AZ::SerializeContext* serializeContext)
AZ::EditContext* ec = serializeContext->GetEditContext();
if (ec)
{
ec->Class< CReflectedVarAnimation >("VarAnimation", "Animation")
->ClassElement(AZ::Edit::ClassElements::EditorData, "")
->Attribute(AZ::Edit::Attributes::NameLabelOverride, &CReflectedVarAnimation::varName)
->Attribute(AZ::Edit::Attributes::DescriptionTextOverride, &CReflectedVarAnimation::description)
;
ec->Class< CReflectedVarResource >("VarResource", "Resource")
->ClassElement(AZ::Edit::ClassElements::EditorData, "")
->Attribute(AZ::Edit::Attributes::NameLabelOverride, &CReflectedVarResource::varName)
@@ -284,8 +272,6 @@ AZ::u32 CReflectedVarGenericProperty::handler()
return AZ_CRC("ePropertyShader", 0xc40932f1);
case ePropertyEquip:
return AZ_CRC("ePropertyEquip", 0x66ffd290);
case ePropertyReverbPreset:
return AZ_CRC("ePropertyReverbPreset", 0x51469f38);
case ePropertyDeprecated0:
return AZ_CRC("ePropertyCustomAction", 0x4ffa5ba5);
case ePropertyGameToken:
Code/Editor/Controls/ReflectedPropertyControl/ReflectedVar.h
-25
View File
@@ -265,32 +265,8 @@ public:
AZ::Vector3 m_color;
};
//Class to hold ePropertyAnimation (IVariable::DT_ANIMATION )
class CReflectedVarAnimation
: public CReflectedVar
{
public:
AZ_RTTI(CReflectedVarAnimation, "{635D982E-23EC-463F-8F33-4FC2C19D5673}", CReflectedVar)
CReflectedVarAnimation(const AZStd::string& name)
: CReflectedVar(name)
, m_entityID(0)
{}
CReflectedVarAnimation()
: m_entityID(0){}
AZStd::string varName() const { return m_varName; }
AZStd::string description() const { return m_description; }
AZStd::string m_animation;
AZ::EntityId m_entityID;
};
//Class to hold:
// ePropertyTexture (IVariable::DT_TEXTURE)
// ePropertyMaterial (IVariable::DT_MATERIAL)
// ePropertyModel (IVariable::DT_OBJECT)
// ePropertyGeomCache (IVariable::DT_GEOM_CACHE)
// ePropertyAudioTrigger (IVariable::DT_AUDIO_TRIGGER)
// ePropertyAudioSwitch (IVariable::DT_AUDIO_SWITCH )
// ePropertyAudioSwitchState (IVariable::DT_AUDIO_SWITCH_STATE)
@@ -344,7 +320,6 @@ public:
AZStd::vector<AZStd::string> m_itemDescriptions;
};
//Class to hold ePropertyAnimation (IVariable::DT_ANIMATION )
class CReflectedVarSpline
: public CReflectedVar
{
Code/Editor/Controls/ReflectedPropertyControl/ReflectedVarWrapper.cpp
+1 -20
View File
@@ -392,25 +392,6 @@ void ReflectedVarColorAdapter::SyncIVarToReflectedVar(IVariable *pVariable)
void ReflectedVarAnimationAdapter::SetVariable(IVariable *pVariable)
{
m_reflectedVar.reset(new CReflectedVarAnimation(pVariable->GetHumanName().toUtf8().data()));
m_reflectedVar->m_description = pVariable->GetDescription().toUtf8().data();
}
void ReflectedVarAnimationAdapter::SyncReflectedVarToIVar(IVariable *pVariable)
{
m_reflectedVar->m_entityID = static_cast<AZ::EntityId>(pVariable->GetUserData().value<AZ::u64>());
m_reflectedVar->m_animation = pVariable->GetDisplayValue().toUtf8().data();
}
void ReflectedVarAnimationAdapter::SyncIVarToReflectedVar(IVariable *pVariable)
{
pVariable->SetUserData(static_cast<AZ::u64>(m_reflectedVar->m_entityID));
pVariable->SetDisplayValue(m_reflectedVar->m_animation.c_str());
}
void ReflectedVarResourceAdapter::SetVariable(IVariable *pVariable)
{
m_reflectedVar.reset(new CReflectedVarResource(pVariable->GetHumanName().toUtf8().data()));
@@ -429,7 +410,7 @@ void ReflectedVarResourceAdapter::SyncReflectedVarToIVar(IVariable *pVariable)
void ReflectedVarResourceAdapter::SyncIVarToReflectedVar(IVariable *pVariable)
{
const bool bForceModified = (m_reflectedVar->m_propertyType == ePropertyGeomCache);
const bool bForceModified = false;
pVariable->SetForceModified(bForceModified);
pVariable->SetDisplayValue(m_reflectedVar->m_path.c_str());
Code/Editor/Controls/ReflectedPropertyControl/ReflectedVarWrapper.h
-14
View File
@@ -218,20 +218,6 @@ AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
};
class EDITOR_CORE_API ReflectedVarAnimationAdapter
: public ReflectedVarAdapter
{
public:
void SetVariable(IVariable* pVariable) override;
void SyncReflectedVarToIVar(IVariable* pVariable) override;
void SyncIVarToReflectedVar(IVariable* pVariable) override;
CReflectedVar* GetReflectedVar() override { return m_reflectedVar.data(); }
private:
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
QScopedPointer<CReflectedVarAnimation > m_reflectedVar;
AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
};
class EDITOR_CORE_API ReflectedVarResourceAdapter
: public ReflectedVarAdapter
{
Code/Editor/Controls/SplineCtrlEx.cpp
+1 -1
View File
@@ -127,7 +127,7 @@ private:
std::vector<int> keySelectionFlags;
_smart_ptr<ISplineBackup> undo;
_smart_ptr<ISplineBackup> redo;
string id;
AZStd::string id;
ISplineInterpolator* pSpline;
};
Code/Editor/Controls/SplineCtrlEx.h
+2 -2
View File
@@ -53,8 +53,8 @@ class QRubberBand;
class ISplineSet
{
public:
virtual ISplineInterpolator* GetSplineFromID(const string& id) = 0;
virtual string GetIDFromSpline(ISplineInterpolator* pSpline) = 0;
virtual ISplineInterpolator* GetSplineFromID(const AZStd::string& id) = 0;
virtual AZStd::string GetIDFromSpline(ISplineInterpolator* pSpline) = 0;
virtual int GetSplineCount() const = 0;
virtual int GetKeyCountAtTime(float time, float threshold) const = 0;
};
Code/Editor/Core/QtEditorApplication.cpp
+2 -5
View File
@@ -206,11 +206,8 @@ namespace
static void LogToDebug([[maybe_unused]] QtMsgType Type, [[maybe_unused]] const QMessageLogContext& Context, const QString& message)
{
#if defined(WIN32) || defined(WIN64)
OutputDebugStringW(L"Qt: ");
OutputDebugStringW(reinterpret_cast<const wchar_t*>(message.utf16()));
OutputDebugStringW(L"\n");
#endif
AZ::Debug::Platform::OutputToDebugger("Qt", message.toUtf8().data());
AZ::Debug::Platform::OutputToDebugger(nullptr, "\n");
}
}
Code/Editor/Core/Tests/test_Main.cpp
+1 -1
View File
@@ -52,7 +52,7 @@ protected:
}
private:
AZ::AllocatorScope<AZ::OSAllocator, AZ::SystemAllocator, AZ::LegacyAllocator, CryStringAllocator> m_allocatorScope;
AZ::AllocatorScope<AZ::OSAllocator, AZ::SystemAllocator, AZ::LegacyAllocator> m_allocatorScope;
SSystemGlobalEnvironment m_stubEnv;
AZ::IO::LocalFileIO m_fileIO;
NiceMock<CryPakMock>* m_cryPak;
Code/Editor/CryEdit.cpp
+20 -28
View File
@@ -286,7 +286,7 @@ bool CCryDocManager::DoPromptFileName(QString& fileName, [[maybe_unused]] UINT n
return false;
}
CCryEditDoc* CCryDocManager::OpenDocumentFile(LPCTSTR lpszFileName, bool bAddToMRU)
CCryEditDoc* CCryDocManager::OpenDocumentFile(const char* lpszFileName, bool bAddToMRU)
{
assert(lpszFileName != nullptr);
@@ -801,12 +801,12 @@ void CCryEditApp::InitDirectory()
// Needed to work with custom memory manager.
//////////////////////////////////////////////////////////////////////////
CCryEditDoc* CCrySingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName, bool bMakeVisible /*= true*/)
CCryEditDoc* CCrySingleDocTemplate::OpenDocumentFile(const char* lpszPathName, bool bMakeVisible /*= true*/)
{
return OpenDocumentFile(lpszPathName, true, bMakeVisible);
}
CCryEditDoc* CCrySingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName, bool bAddToMRU, [[maybe_unused]] bool bMakeVisible)
CCryEditDoc* CCrySingleDocTemplate::OpenDocumentFile(const char* lpszPathName, bool bAddToMRU, [[maybe_unused]] bool bMakeVisible)
{
CCryEditDoc* pCurDoc = GetIEditor()->GetDocument();
@@ -845,7 +845,7 @@ CCryEditDoc* CCrySingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName, bool
return pCurDoc;
}
CCrySingleDocTemplate::Confidence CCrySingleDocTemplate::MatchDocType(LPCTSTR lpszPathName, CCryEditDoc*& rpDocMatch)
CCrySingleDocTemplate::Confidence CCrySingleDocTemplate::MatchDocType(const char* lpszPathName, CCryEditDoc*& rpDocMatch)
{
assert(lpszPathName != nullptr);
rpDocMatch = nullptr;
@@ -891,8 +891,7 @@ CCrySingleDocTemplate::Confidence CCrySingleDocTemplate::MatchDocType(LPCTSTR lp
/////////////////////////////////////////////////////////////////////////////
namespace
{
CryMutex g_splashScreenStateLock;
CryConditionVariable g_splashScreenStateChange;
AZStd::mutex g_splashScreenStateLock;
enum ESplashScreenState
{
eSplashScreenState_Init, eSplashScreenState_Started, eSplashScreenState_Destroy
@@ -923,7 +922,7 @@ QString FormatRichTextCopyrightNotice()
/////////////////////////////////////////////////////////////////////////////
void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
{
g_splashScreenStateLock.Lock();
g_splashScreenStateLock.lock();
CStartupLogoDialog* splashScreen = new CStartupLogoDialog(FormatVersion(app->m_pEditor->GetFileVersion()), FormatRichTextCopyrightNotice());
@@ -931,8 +930,7 @@ void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
g_splashScreen = splashScreen;
g_splashScreenState = eSplashScreenState_Started;
g_splashScreenStateLock.Unlock();
g_splashScreenStateChange.Notify();
g_splashScreenStateLock.unlock();
splashScreen->show();
// Make sure the initial paint of the splash screen occurs so we dont get stuck with a blank window
@@ -940,10 +938,9 @@ void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
QObject::connect(splashScreen, &QObject::destroyed, splashScreen, [=]
{
g_splashScreenStateLock.Lock();
AZStd::scoped_lock lock(g_splashScreenStateLock);
g_pInitializeUIInfo = nullptr;
g_splashScreen = nullptr;
g_splashScreenStateLock.Unlock();
});
}
@@ -973,9 +970,9 @@ void CCryEditApp::CloseSplashScreen()
if (CStartupLogoDialog::instance())
{
delete CStartupLogoDialog::instance();
g_splashScreenStateLock.Lock();
g_splashScreenStateLock.lock();
g_splashScreenState = eSplashScreenState_Destroy;
g_splashScreenStateLock.Unlock();
g_splashScreenStateLock.unlock();
}
GetIEditor()->Notify(eNotify_OnSplashScreenDestroyed);
@@ -984,12 +981,12 @@ void CCryEditApp::CloseSplashScreen()
/////////////////////////////////////////////////////////////////////////////
void CCryEditApp::OutputStartupMessage(QString str)
{
g_splashScreenStateLock.Lock();
g_splashScreenStateLock.lock();
if (g_pInitializeUIInfo)
{
g_pInitializeUIInfo->SetInfoText(str.toUtf8().data());
}
g_splashScreenStateLock.Unlock();
g_splashScreenStateLock.unlock();
}
//////////////////////////////////////////////////////////////////////////
@@ -1864,11 +1861,6 @@ void CCryEditApp::UnregisterEventLoopHook(IEventLoopHook* pHookToRemove)
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::LoadFile(QString fileName)
{
//CEditCommandLineInfo cmdLine;
//ProcessCommandLine(cmdinfo);
//bool bBuilding = false;
//CString file = cmdLine.SpanExcluding()
if (GetIEditor()->GetViewManager()->GetViewCount() == 0)
{
return;
@@ -3193,7 +3185,7 @@ bool CCryEditApp::CreateLevel(bool& wasCreateLevelOperationCancelled)
GetIEditor()->GetDocument()->DeleteTemporaryLevel();
}
if (levelName.length() == 0 || !CryStringUtils::IsValidFileName(levelName.toUtf8().data()))
if (levelName.length() == 0 || !AZ::StringFunc::Path::IsValid(levelName.toUtf8().data()))
{
QMessageBox::critical(AzToolsFramework::GetActiveWindow(), QString(), QObject::tr("Level name is invalid, please choose another name."));
return false;
@@ -3226,13 +3218,16 @@ bool CCryEditApp::CreateLevel(bool& wasCreateLevelOperationCancelled)
DWORD dw = GetLastError();
#ifdef WIN32
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
wchar_t windowsErrorMessageW[ERROR_LEN];
windowsErrorMessageW[0] = L'\0';
FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
windowsErrorMessage.data(),
windowsErrorMessage.length(), nullptr);
windowsErrorMessageW,
ERROR_LEN, nullptr);
_getcwd(cwd.data(), cwd.length());
AZStd::to_string(windowsErrorMessage.data(), ERROR_LEN, windowsErrorMessageW);
#else
windowsErrorMessage = strerror(dw);
cwd = QDir::currentPath().toUtf8();
@@ -3306,7 +3301,7 @@ void CCryEditApp::OnOpenSlice()
}
//////////////////////////////////////////////////////////////////////////
CCryEditDoc* CCryEditApp::OpenDocumentFile(LPCTSTR lpszFileName)
CCryEditDoc* CCryEditApp::OpenDocumentFile(const char* lpszFileName)
{
if (m_openingLevel)
{
@@ -4001,15 +3996,12 @@ struct CryAllocatorsRAII
CryAllocatorsRAII()
{
AZ_Assert(!AZ::AllocatorInstance<AZ::LegacyAllocator>::IsReady(), "Expected allocator to not be initialized, hunt down the static that is initializing it");
AZ_Assert(!AZ::AllocatorInstance<CryStringAllocator>::IsReady(), "Expected allocator to not be initialized, hunt down the static that is initializing it");
AZ::AllocatorInstance<AZ::LegacyAllocator>::Create();
AZ::AllocatorInstance<CryStringAllocator>::Create();
}
~CryAllocatorsRAII()
{
AZ::AllocatorInstance<CryStringAllocator>::Destroy();
AZ::AllocatorInstance<AZ::LegacyAllocator>::Destroy();
}
};
Code/Editor/CryEdit.h
+5 -5
View File
@@ -174,7 +174,7 @@ public:
virtual bool InitInstance();
virtual int ExitInstance(int exitCode = 0);
virtual bool OnIdle(LONG lCount);
virtual CCryEditDoc* OpenDocumentFile(LPCTSTR lpszFileName);
virtual CCryEditDoc* OpenDocumentFile(const char* lpszFileName);
CCryDocManager* GetDocManager() { return m_pDocManager; }
@@ -448,9 +448,9 @@ public:
~CCrySingleDocTemplate() {};
// avoid creating another CMainFrame
// close other type docs before opening any things
virtual CCryEditDoc* OpenDocumentFile(LPCTSTR lpszPathName, bool bAddToMRU, bool bMakeVisible);
virtual CCryEditDoc* OpenDocumentFile(LPCTSTR lpszPathName, bool bMakeVisible = true);
virtual Confidence MatchDocType(LPCTSTR lpszPathName, CCryEditDoc*& rpDocMatch);
virtual CCryEditDoc* OpenDocumentFile(const char* lpszPathName, bool bAddToMRU, bool bMakeVisible);
virtual CCryEditDoc* OpenDocumentFile(const char* lpszPathName, bool bMakeVisible = TRUE);
virtual Confidence MatchDocType(const char* lpszPathName, CCryEditDoc*& rpDocMatch);
private:
const QMetaObject* m_documentClass = nullptr;
@@ -467,7 +467,7 @@ public:
virtual void OnFileNew();
virtual bool DoPromptFileName(QString& fileName, UINT nIDSTitle,
DWORD lFlags, bool bOpenFileDialog, CDocTemplate* pTemplate);
virtual CCryEditDoc* OpenDocumentFile(LPCTSTR lpszFileName, bool bAddToMRU);
virtual CCryEditDoc* OpenDocumentFile(const char* lpszFileName, bool bAddToMRU);
QVector<CCrySingleDocTemplate*> m_templateList;
};
Code/Editor/CryEditDoc.cpp
+4 -4
View File
@@ -418,8 +418,8 @@ void CCryEditDoc::Load(TDocMultiArchive& arrXmlAr, const QString& szFilename)
Audio::AudioSystemRequestBus::BroadcastResult(controlsPath, &Audio::AudioSystemRequestBus::Events::GetControlsPath);
QString sAudioLevelPath(controlsPath);
sAudioLevelPath += "levels/";
string const sLevelNameOnly = PathUtil::GetFileName(fileName.toUtf8().data());
sAudioLevelPath += sLevelNameOnly;
AZStd::string const sLevelNameOnly = PathUtil::GetFileName(fileName.toUtf8().data());
sAudioLevelPath += sLevelNameOnly.c_str();
QByteArray path = sAudioLevelPath.toUtf8();
Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_CONTROLS_DATA> oAMData(path, Audio::eADS_LEVEL_SPECIFIC);
Audio::SAudioRequest oAudioRequestData;
@@ -1909,7 +1909,7 @@ void CCryEditDoc::LogLoadTime(int time) const
CLogFile::FormatLine("[LevelLoadTime] Level %s loaded in %d seconds", level.toUtf8().data(), time / 1000);
#if defined(AZ_PLATFORM_WINDOWS)
SetFileAttributes(filename.toUtf8().data(), FILE_ATTRIBUTE_ARCHIVE);
SetFileAttributesW(filename.toStdWString().c_str(), FILE_ATTRIBUTE_ARCHIVE);
#endif
QFile file(filename);
@@ -2134,7 +2134,7 @@ void CCryEditDoc::OnEnvironmentPropertyChanged(IVariable* pVar)
childNode->setAttr("value", childValue.toUtf8().data());
}
QString CCryEditDoc::GetCryIndexPath(const LPCTSTR levelFilePath) const
QString CCryEditDoc::GetCryIndexPath(const char* levelFilePath) const
{
QString levelPath = Path::GetPath(levelFilePath);
QString levelName = Path::GetFileName(levelFilePath);
Code/Editor/CryEditDoc.h
+1 -1
View File
@@ -180,7 +180,7 @@ protected:
void OnStartLevelResourceList();
static void OnValidateSurfaceTypesChanged(ICVar*);
QString GetCryIndexPath(const LPCTSTR levelFilePath) const;
QString GetCryIndexPath(const char* levelFilePath) const;
//////////////////////////////////////////////////////////////////////////
// SliceEditorEntityOwnershipServiceNotificationBus::Handler
Code/Editor/CryEditPy.cpp
+2 -2
View File
@@ -210,7 +210,7 @@ namespace
const char* PyGetCurrentLevelName()
{
// Using static member to capture temporary data
static string tempLevelName;
static AZ::IO::FixedMaxPathString tempLevelName;
tempLevelName = GetIEditor()->GetGameEngine()->GetLevelName().toUtf8().data();
return tempLevelName.c_str();
}
@@ -218,7 +218,7 @@ namespace
const char* PyGetCurrentLevelPath()
{
// Using static member to capture temporary data
static string tempLevelPath;
static AZ::IO::FixedMaxPathString tempLevelPath;
tempLevelPath = GetIEditor()->GetGameEngine()->GetLevelPath().toUtf8().data();
return tempLevelPath.c_str();
}
Code/Editor/EditorFileMonitor.cpp
+6 -6
View File
@@ -55,10 +55,10 @@ bool CEditorFileMonitor::RegisterListener(IFileChangeListener* pListener, const
//////////////////////////////////////////////////////////////////////////
static string CanonicalizePath(const char* path)
static AZStd::string CanonicalizePath(const char* path)
{
auto canon = QFileInfo(path).canonicalFilePath();
return canon.isEmpty() ? string(path) : string(canon.toUtf8());
return canon.isEmpty() ? AZStd::string(path) : AZStd::string(canon.toUtf8());
}
//////////////////////////////////////////////////////////////////////////
@@ -66,8 +66,8 @@ bool CEditorFileMonitor::RegisterListener(IFileChangeListener* pListener, const
{
bool success = true;
string gameFolder = Path::GetEditingGameDataFolder().c_str();
string naivePath;
AZStd::string gameFolder = Path::GetEditingGameDataFolder().c_str();
AZStd::string naivePath;
CFileChangeMonitor* fileChangeMonitor = CFileChangeMonitor::Instance();
AZ_Assert(fileChangeMonitor, "CFileChangeMonitor singleton missing.");
@@ -75,12 +75,12 @@ bool CEditorFileMonitor::RegisterListener(IFileChangeListener* pListener, const
// Append slash in preparation for appending the second part.
naivePath = PathUtil::AddSlash(naivePath);
naivePath += sFolderRelativeToGame;
naivePath.replace('/', '\\');
AZ::StringFunc::Replace(naivePath, '/', '\\');
// Remove the final slash if the given item is a folder so the file change monitor correctly picks up on it.
naivePath = PathUtil::RemoveSlash(naivePath);
string canonicalizedPath = CanonicalizePath(naivePath.c_str());
AZStd::string canonicalizedPath = CanonicalizePath(naivePath.c_str());
if (fileChangeMonitor->IsDirectory(canonicalizedPath.c_str()) || fileChangeMonitor->IsFile(canonicalizedPath.c_str()))
{
Code/Editor/EditorPanelUtils.cpp
+2 -2
View File
@@ -130,7 +130,7 @@ public:
HotKey_BuildDefaults();
for (QPair<QString, QString> key : keys)
{
for (unsigned int j = 0; j < hotkeys.count(); j++)
for (int j = 0; j < hotkeys.count(); j++)
{
if (hotkeys[j].path.compare(key.first, Qt::CaseInsensitive) == 0)
{
@@ -256,7 +256,7 @@ public:
hotkey.second = settings.value("keySequence").toString();
if (!hotkey.first.isEmpty())
{
for (unsigned int j = 0; j < hotkeys.count(); j++)
for (int j = 0; j < hotkeys.count(); j++)
{
if (hotkeys[j].path.compare(hotkey.first, Qt::CaseInsensitive) == 0)
{
Code/Editor/EditorPreferencesPageViewportMovement.cpp
+13 -37
View File
@@ -68,45 +68,21 @@ QIcon& CEditorPreferencesPage_ViewportMovement::GetIcon()
void CEditorPreferencesPage_ViewportMovement::OnApply()
{
if (SandboxEditor::UsingNewCameraSystem())
{
SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_moveSpeed);
SandboxEditor::SetCameraRotateSpeed(m_cameraMovementSettings.m_rotateSpeed);
SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_fastMoveSpeed);
SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_wheelZoomSpeed);
SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_invertYRotation);
SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_invertPan);
SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_invertPan);
}
else
{
gSettings.cameraMoveSpeed = m_cameraMovementSettings.m_moveSpeed;
gSettings.cameraRotateSpeed = m_cameraMovementSettings.m_rotateSpeed;
gSettings.cameraFastMoveSpeed = m_cameraMovementSettings.m_fastMoveSpeed;
gSettings.wheelZoomSpeed = m_cameraMovementSettings.m_wheelZoomSpeed;
gSettings.invertYRotation = m_cameraMovementSettings.m_invertYRotation;
gSettings.invertPan = m_cameraMovementSettings.m_invertPan;
}
SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_moveSpeed);
SandboxEditor::SetCameraRotateSpeed(m_cameraMovementSettings.m_rotateSpeed);
SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_fastMoveSpeed);
SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_wheelZoomSpeed);
SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_invertYRotation);
SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_invertPan);
SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_invertPan);
}
void CEditorPreferencesPage_ViewportMovement::InitializeSettings()
{
if (SandboxEditor::UsingNewCameraSystem())
{
m_cameraMovementSettings.m_moveSpeed = SandboxEditor::CameraTranslateSpeed();
m_cameraMovementSettings.m_rotateSpeed = SandboxEditor::CameraRotateSpeed();
m_cameraMovementSettings.m_fastMoveSpeed = SandboxEditor::CameraBoostMultiplier();
m_cameraMovementSettings.m_wheelZoomSpeed = SandboxEditor::CameraScrollSpeed();
m_cameraMovementSettings.m_invertYRotation = SandboxEditor::CameraOrbitYawRotationInverted();
m_cameraMovementSettings.m_invertPan = SandboxEditor::CameraPanInvertedX() && SandboxEditor::CameraPanInvertedY();
}
else
{
m_cameraMovementSettings.m_moveSpeed = gSettings.cameraMoveSpeed;
m_cameraMovementSettings.m_rotateSpeed = gSettings.cameraRotateSpeed;
m_cameraMovementSettings.m_fastMoveSpeed = gSettings.cameraFastMoveSpeed;
m_cameraMovementSettings.m_wheelZoomSpeed = gSettings.wheelZoomSpeed;
m_cameraMovementSettings.m_invertYRotation = gSettings.invertYRotation;
m_cameraMovementSettings.m_invertPan = gSettings.invertPan;
}
m_cameraMovementSettings.m_moveSpeed = SandboxEditor::CameraTranslateSpeed();
m_cameraMovementSettings.m_rotateSpeed = SandboxEditor::CameraRotateSpeed();
m_cameraMovementSettings.m_fastMoveSpeed = SandboxEditor::CameraBoostMultiplier();
m_cameraMovementSettings.m_wheelZoomSpeed = SandboxEditor::CameraScrollSpeed();
m_cameraMovementSettings.m_invertYRotation = SandboxEditor::CameraOrbitYawRotationInverted();
m_cameraMovementSettings.m_invertPan = SandboxEditor::CameraPanInvertedX() && SandboxEditor::CameraPanInvertedY();
}
Code/Editor/EditorViewportSettings.h
-4
View File
@@ -118,8 +118,4 @@ namespace SandboxEditor
SANDBOX_API AzFramework::InputChannelId CameraOrbitPanChannelId();
SANDBOX_API void SetCameraOrbitPanChannelId(AZStd::string_view cameraOrbitPanId);
//! Return if the new editor camera system is enabled or not.
//! @note This is implemented in EditorViewportWidget.cpp
SANDBOX_API bool UsingNewCameraSystem();
} // namespace SandboxEditor
Code/Editor/EditorViewportWidget.cpp
+4 -23
View File
@@ -72,7 +72,6 @@
#include "IPostEffectGroup.h"
#include "EditorPreferencesPageGeneral.h"
#include "ViewportManipulatorController.h"
#include "LegacyViewportCameraController.h"
#include "EditorViewportSettings.h"
#include "ViewPane.h"
@@ -105,17 +104,8 @@
AZ_CVAR(
bool, ed_visibility_logTiming, false, nullptr, AZ::ConsoleFunctorFlags::Null, "Output the timing of the new IVisibilitySystem query");
AZ_CVAR(bool, ed_useNewCameraSystem, true, nullptr, AZ::ConsoleFunctorFlags::Null, "Use the new Editor camera system");
AZ_CVAR(bool, ed_showCursorCameraLook, true, nullptr, AZ::ConsoleFunctorFlags::Null, "Show the cursor when using free look with the new camera system");
namespace SandboxEditor
{
bool UsingNewCameraSystem()
{
return ed_useNewCameraSystem;
}
} // namespace SandboxEditor
EditorViewportWidget* EditorViewportWidget::m_pPrimaryViewport = nullptr;
#if AZ_TRAIT_OS_PLATFORM_APPLE
@@ -640,7 +630,7 @@ void EditorViewportWidget::OnEditorNotifyEvent(EEditorNotifyEvent event)
if (m_renderViewport)
{
m_renderViewport->GetControllerList()->SetEnabled(true);
m_renderViewport->SetInputProcessingEnabled(true);
}
break;
@@ -1274,15 +1264,8 @@ void EditorViewportWidget::SetViewportId(int id)
m_renderViewport->GetControllerList()->Add(AZStd::make_shared<SandboxEditor::ViewportManipulatorController>());
if (ed_useNewCameraSystem)
{
m_renderViewport->GetControllerList()->Add(CreateModularViewportCameraController(AzFramework::ViewportId(id)));
}
else
{
m_renderViewport->GetControllerList()->Add(AZStd::make_shared<SandboxEditor::LegacyViewportCameraController>());
}
m_renderViewport->GetControllerList()->Add(CreateModularViewportCameraController(AzFramework::ViewportId(id)));
m_renderViewport->SetViewportSettings(&g_EditorViewportSettings);
UpdateScene();
@@ -2239,7 +2222,6 @@ void EditorViewportWidget::CenterOnAABB(const AABB& aabb)
orbitDistance = fabs(orbitDistance);
SetViewTM(newTM);
SandboxEditor::OrbitCameraControlsBus::Event(GetViewportId(), &SandboxEditor::OrbitCameraControlsBus::Events::SetOrbitDistance, orbitDistance);
}
void EditorViewportWidget::CenterOnSliceInstance()
@@ -2715,8 +2697,7 @@ void EditorViewportWidget::RestoreViewportAfterGameMode()
QString(
tr("When leaving \" Game Mode \" the engine will automatically restore your camera position to the default position before you "
"had entered Game mode.<br/><br/><small>If you dislike this setting you can always change this anytime in the global "
"preferences.</small><br/><br/>"))
.arg(EditorPreferencesGeneralRestoreViewportCameraSettingName);
"preferences.</small><br/><br/>"));
QString restoreOnExitGameModePopupDisabledRegKey("Editor/AutoHide/ViewportCameraRestoreOnExitGameMode");
// Read the popup disabled registry value
Code/Editor/Export/ExportManager.cpp
+3 -3
View File
@@ -45,7 +45,7 @@ namespace
SEfResTexture* pTex = pRes->GetTextureResource(nSlot);
if (pTex)
{
cry_strcat(outName, Path::GamePathToFullPath(pTex->m_Name.c_str()).toUtf8().data());
azstrcat(outName, AZ_ARRAY_SIZE(outName), Path::GamePathToFullPath(pTex->m_Name.c_str()).toUtf8().data());
}
}
@@ -87,7 +87,7 @@ Export::CObject::CObject(const char* pName)
nParent = -1;
cry_strcpy(name, pName);
azstrcpy(name, AZ_ARRAY_SIZE(name), pName);
materialName[0] = '\0';
@@ -101,7 +101,7 @@ Export::CObject::CObject(const char* pName)
void Export::CObject::SetMaterialName(const char* pName)
{
cry_strcpy(materialName, pName);
azstrcpy(materialName, AZ_ARRAY_SIZE(materialName), pName);
}
Code/Editor/GameEngine.h
+2 -2
View File
@@ -116,11 +116,11 @@ public:
//! mutex used by other threads to lock up the PAK modification,
//! so only one thread can modify the PAK at once
static CryMutex& GetPakModifyMutex()
static AZStd::recursive_mutex& GetPakModifyMutex()
{
//! mutex used to halt copy process while the export to game
//! or other pak operation is done in the main thread
static CryMutex s_pakModifyMutex;
static AZStd::recursive_mutex s_pakModifyMutex;
return s_pakModifyMutex;
}
Code/Editor/GameExporter.cpp
+8 -8
View File
@@ -136,7 +136,7 @@ bool CGameExporter::Export(unsigned int flags, [[maybe_unused]] EEndian eExportE
m_settings.SetHiQuality();
}
CryAutoLock<CryMutex> autoLock(CGameEngine::GetPakModifyMutex());
AZStd::scoped_lock autoLock(CGameEngine::GetPakModifyMutex());
// Close this pak file.
if (!CloseLevelPack(m_levelPak, true))
@@ -378,14 +378,14 @@ void CGameExporter::ExportFileList(const QString& path, const QString& levelName
{
// process the folder of the specified map name, producing a filelist.xml file
// that can later be used for map downloads
string newpath;
AZStd::string newpath;
QString filename = levelName;
string mapname = (filename + ".dds").toUtf8().data();
string metaname = (filename + ".xml").toUtf8().data();
AZStd::string filename = levelName.toUtf8().data();
AZStd::string mapname = (filename + ".dds");
AZStd::string metaname = (filename + ".xml");
XmlNodeRef rootNode = gEnv->pSystem->CreateXmlNode("download");
rootNode->setAttr("name", filename.toUtf8().data());
rootNode->setAttr("name", filename.c_str());
rootNode->setAttr("type", "Map");
XmlNodeRef indexNode = rootNode->newChild("index");
if (indexNode)
@@ -434,9 +434,9 @@ void CGameExporter::ExportFileList(const QString& path, const QString& levelName
newFileNode->setAttr("size", handle.m_fileDesc.nSize);
unsigned char md5[16];
string filenameToHash = GetIEditor()->GetGameEngine()->GetLevelPath().toUtf8().data();
AZStd::string filenameToHash = GetIEditor()->GetGameEngine()->GetLevelPath().toUtf8().data();
filenameToHash += "/";
filenameToHash += string{ handle.m_filename.data(), handle.m_filename.size() };
filenameToHash += AZStd::string{ handle.m_filename.data(), handle.m_filename.size() };
if (gEnv->pCryPak->ComputeMD5(filenameToHash.data(), md5))
{
char md5string[33];
Code/Editor/GenericSelectItemDialog.cpp
-14
View File
@@ -91,20 +91,6 @@ void CGenericSelectItemDialog::ReloadTree()
QTreeWidgetItem* hSelected = nullptr;
/*
std::vector<CString>::const_iterator iter = m_items.begin();
while (iter != m_items.end())
{
const CString& itemName = *iter;
HTREEITEM hItem = m_tree.InsertItem(itemName, 0, 0, TVI_ROOT, TVI_SORT);
if (!m_preselect.IsEmpty() && m_preselect.CompareNoCase(itemName) == 0)
{
hSelected = hItem;
}
++iter;
}
*/
std::map<QString, QTreeWidgetItem*, less_qstring_icmp> items;
QRegularExpression sep(QStringLiteral("[\\/.") + m_treeSeparator + QStringLiteral("]+"));
Code/Editor/GotoPositionDlg.cpp
+5 -17
View File
@@ -108,24 +108,12 @@ void GotoPositionDialog::OnUpdateNumbers()
void GotoPositionDialog::accept()
{
if (SandboxEditor::UsingNewCameraSystem())
{
SandboxEditor::InterpolateDefaultViewportCameraToTransform(
AZ::Vector3(
aznumeric_cast<float>(m_ui->m_dymX->value()), aznumeric_cast<float>(m_ui->m_dymY->value()),
aznumeric_cast<float>(m_ui->m_dymZ->value())),
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAnglePitch->value())),
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAngleYaw->value())));
}
else
{
SandboxEditor::SetDefaultViewportCameraPosition(AZ::Vector3(
SandboxEditor::InterpolateDefaultViewportCameraToTransform(
AZ::Vector3(
aznumeric_cast<float>(m_ui->m_dymX->value()), aznumeric_cast<float>(m_ui->m_dymY->value()),
aznumeric_cast<float>(m_ui->m_dymZ->value())));
SandboxEditor::SetDefaultViewportCameraRotation(
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAnglePitch->value())),
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAngleYaw->value())));
}
aznumeric_cast<float>(m_ui->m_dymZ->value())),
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAnglePitch->value())),
AZ::DegToRad(aznumeric_cast<float>(m_ui->m_dymAngleYaw->value())));
QDialog::accept();
}
Code/Editor/IEditor.h
-2
View File
@@ -68,7 +68,6 @@ class CDisplaySettings;
struct SGizmoParameters;
class CLevelIndependentFileMan;
class CSelectionTreeManager;
struct IResourceSelectorHost;
struct SEditorSettings;
class CGameExporter;
class IAWSResourceManager;
@@ -714,7 +713,6 @@ struct IEditor
virtual ESystemConfigSpec GetEditorConfigSpec() const = 0;
virtual ESystemConfigPlatform GetEditorConfigPlatform() const = 0;
virtual void ReloadTemplates() = 0;
virtual IResourceSelectorHost* GetResourceSelectorHost() = 0;
virtual void ShowStatusText(bool bEnable) = 0;
// Provides a way to extend the context menu of an object. The function gets called every time the menu is opened.
Code/Editor/IEditorImpl.cpp
+22 -21
View File
@@ -26,6 +26,7 @@ AZ_POP_DISABLE_WARNING
#include <AzCore/IO/Path/Path.h>
#include <AzCore/JSON/document.h>
#include <AzCore/Settings/SettingsRegistryMergeUtils.h>
#include <AzCore/Utils/Utils.h>
// AzFramework
#include <AzFramework/Terrain/TerrainDataRequestBus.h>
@@ -66,7 +67,6 @@ AZ_POP_DISABLE_WARNING
#include "EditorFileMonitor.h"
#include "MainStatusBar.h"
#include "ResourceSelectorHost.h"
#include "Util/FileUtil_impl.h"
#include "Util/ImageUtil_impl.h"
#include "LogFileImpl.h"
@@ -186,7 +186,6 @@ CEditorImpl::CEditorImpl()
m_pAnimationContext = new CAnimationContext;
m_pImageUtil = new CImageUtil_impl();
m_pResourceSelectorHost.reset(CreateResourceSelectorHost());
m_selectedRegion.min = Vec3(0, 0, 0);
m_selectedRegion.max = Vec3(0, 0, 0);
DetectVersion();
@@ -251,7 +250,7 @@ void CEditorImpl::Uninitialize()
void CEditorImpl::UnloadPlugins()
{
CryAutoLock<CryMutex> lock(m_pluginMutex);
AZStd::scoped_lock lock(m_pluginMutex);
// Flush core buses. We're about to unload DLLs and need to ensure we don't have module-owned functions left behind.
AZ::Data::AssetBus::ExecuteQueuedEvents();
@@ -272,7 +271,7 @@ void CEditorImpl::UnloadPlugins()
void CEditorImpl::LoadPlugins()
{
CryAutoLock<CryMutex> lock(m_pluginMutex);
AZStd::scoped_lock lock(m_pluginMutex);
static const QString editor_plugins_folder("EditorPlugins");
@@ -1107,16 +1106,18 @@ void CEditorImpl::DetectVersion()
DWORD dwHandle;
UINT len;
char ver[1024 * 8];
wchar_t ver[1024 * 8];
GetModuleFileName(nullptr, exe, _MAX_PATH);
AZ::Utils::GetExecutablePath(exe, _MAX_PATH);
AZStd::wstring exeW;
AZStd::to_wstring(exeW, exe);
int verSize = GetFileVersionInfoSize(exe, &dwHandle);
int verSize = GetFileVersionInfoSizeW(exeW.c_str(), &dwHandle);
if (verSize > 0)
{
GetFileVersionInfo(exe, dwHandle, 1024 * 8, ver);
GetFileVersionInfoW(exeW.c_str(), dwHandle, 1024 * 8, ver);
VS_FIXEDFILEINFO* vinfo;
VerQueryValue(ver, "\\", (void**)&vinfo, &len);
VerQueryValueW(ver, L"\\", (void**)&vinfo, &len);
m_fileVersion.v[0] = vinfo->dwFileVersionLS & 0xFFFF;
m_fileVersion.v[1] = vinfo->dwFileVersionLS >> 16;
@@ -1457,7 +1458,7 @@ void CEditorImpl::UnregisterNotifyListener(IEditorNotifyListener* listener)
ISourceControl* CEditorImpl::GetSourceControl()
{
CryAutoLock<CryMutex> lock(m_pluginMutex);
AZStd::scoped_lock lock(m_pluginMutex);
if (m_pSourceControl)
{
@@ -1557,31 +1558,31 @@ IExportManager* CEditorImpl::GetExportManager()
void CEditorImpl::AddUIEnums()
{
// Spec settings for shadow casting lights
string SpecString[4];
AZStd::string SpecString[4];
QStringList types;
types.push_back("Never=0");
SpecString[0].Format("VeryHigh Spec=%d", CONFIG_VERYHIGH_SPEC);
SpecString[0] = AZStd::string::format("VeryHigh Spec=%d", CONFIG_VERYHIGH_SPEC);
types.push_back(SpecString[0].c_str());
SpecString[1].Format("High Spec=%d", CONFIG_HIGH_SPEC);
SpecString[1] = AZStd::string::format("High Spec=%d", CONFIG_HIGH_SPEC);
types.push_back(SpecString[1].c_str());
SpecString[2].Format("Medium Spec=%d", CONFIG_MEDIUM_SPEC);
SpecString[2] = AZStd::string::format("Medium Spec=%d", CONFIG_MEDIUM_SPEC);
types.push_back(SpecString[2].c_str());
SpecString[3].Format("Low Spec=%d", CONFIG_LOW_SPEC);
SpecString[3] = AZStd::string::format("Low Spec=%d", CONFIG_LOW_SPEC);
types.push_back(SpecString[3].c_str());
m_pUIEnumsDatabase->SetEnumStrings("CastShadows", types);
// Power-of-two percentages
string percentStringPOT[5];
AZStd::string percentStringPOT[5];
types.clear();
percentStringPOT[0].Format("Default=%d", 0);
percentStringPOT[0] = AZStd::string::format("Default=%d", 0);
types.push_back(percentStringPOT[0].c_str());
percentStringPOT[1].Format("12.5=%d", 1);
percentStringPOT[1] = AZStd::string::format("12.5=%d", 1);
types.push_back(percentStringPOT[1].c_str());
percentStringPOT[2].Format("25=%d", 2);
percentStringPOT[2] = AZStd::string::format("25=%d", 2);
types.push_back(percentStringPOT[2].c_str());
percentStringPOT[3].Format("50=%d", 3);
percentStringPOT[3] = AZStd::string::format("50=%d", 3);
types.push_back(percentStringPOT[3].c_str());
percentStringPOT[4].Format("100=%d", 4);
percentStringPOT[4] = AZStd::string::format("100=%d", 4);
types.push_back(percentStringPOT[4].c_str());
m_pUIEnumsDatabase->SetEnumStrings("ShadowMinResPercent", types);
}
Code/Editor/IEditorImpl.h
+1 -3
View File
@@ -290,7 +290,6 @@ public:
ESystemConfigPlatform GetEditorConfigPlatform() const;
void ReloadTemplates();
void AddErrorMessage(const QString& text, const QString& caption);
IResourceSelectorHost* GetResourceSelectorHost() { return m_pResourceSelectorHost.get(); }
virtual void ShowStatusText(bool bEnable);
void OnObjectContextMenuOpened(QMenu* pMenu, const CBaseObject* pObject);
@@ -374,7 +373,6 @@ protected:
//! Export manager for exporting objects and a terrain from the game to DCC tools
CExportManager* m_pExportManager;
std::unique_ptr<CEditorFileMonitor> m_pEditorFileMonitor;
std::unique_ptr<IResourceSelectorHost> m_pResourceSelectorHost;
QString m_selectFileBuffer;
QString m_levelNameBuffer;
@@ -401,7 +399,7 @@ protected:
IImageUtil* m_pImageUtil; // Vladimir@conffx
ILogFile* m_pLogFile; // Vladimir@conffx
CryMutex m_pluginMutex; // protect any pointers that come from plugins, such as the source control cached pointer.
AZStd::mutex m_pluginMutex; // protect any pointers that come from plugins, such as the source control cached pointer.
static const char* m_crashLogFileName;
};
Code/Editor/IEditorPanelUtils.h
+1 -1
View File
@@ -65,7 +65,7 @@ struct HotKey
int size = (m_catSize < o_catSize) ? m_catSize : o_catSize;
//sort categories to keep them together
for (unsigned int i = 0; i < size; i++)
for (int i = 0; i < size; i++)
{
if (m_categories[i] < o_categories[i])
{
Code/Editor/Include/Command.h
+67 -67
View File
@@ -18,7 +18,7 @@
#include "Util/EditorUtils.h"
inline string ToString(const QString& s)
inline AZStd::string ToString(const QString& s)
{
return s.toUtf8().data();
}
@@ -27,10 +27,10 @@ class CCommand
{
public:
CCommand(
const string& module,
const string& name,
const string& description,
const string& example)
const AZStd::string& module,
const AZStd::string& name,
const AZStd::string& description,
const AZStd::string& example)
: m_module(module)
, m_name(name)
, m_description(description)
@@ -79,20 +79,20 @@ public:
}
int GetArgCount() const
{ return m_args.size(); }
const string& GetArg(int i) const
const AZStd::string& GetArg(int i) const
{
assert(0 <= i && i < GetArgCount());
return m_args[i];
}
private:
DynArray<string> m_args;
DynArray<AZStd::string> m_args;
unsigned char m_stringFlags; // This is needed to quote string parameters when logging a command.
};
const string& GetName() const { return m_name; }
const string& GetModule() const { return m_module; }
const string& GetDescription() const { return m_description; }
const string& GetExample() const { return m_example; }
const AZStd::string& GetName() const { return m_name; }
const AZStd::string& GetModule() const { return m_module; }
const AZStd::string& GetDescription() const { return m_description; }
const AZStd::string& GetExample() const { return m_example; }
void SetAvailableInScripting() { m_bAlsoAvailableInScripting = true; };
bool IsAvailableInScripting() const { return m_bAlsoAvailableInScripting; }
@@ -104,15 +104,15 @@ public:
protected:
friend class CEditorCommandManager;
string m_module;
string m_name;
string m_description;
string m_example;
AZStd::string m_module;
AZStd::string m_name;
AZStd::string m_description;
AZStd::string m_example;
bool m_bAlsoAvailableInScripting;
template <typename T>
static string ToString_(T t) { return ::ToString(t); }
static inline string ToString_(const char* val)
static AZStd::string ToString_(T t) { return ::ToString(t); }
static inline AZStd::string ToString_(const char* val)
{ return val; }
template <typename T>
static bool FromString_(T& t, const char* s) { return ::FromString(t, s); }
@@ -137,8 +137,8 @@ class CCommand0
: public CCommand
{
public:
CCommand0(const string& module, const string& name,
const string& description, const string& example,
CCommand0(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void()>& functor)
: CCommand(module, name, description, example)
, m_functor(functor) {}
@@ -146,10 +146,10 @@ public:
// UI metadata for this command, if any
struct SUIInfo
{
string caption;
string tooltip;
string description;
string iconFilename;
AZStd::string caption;
AZStd::string tooltip;
AZStd::string description;
AZStd::string iconFilename;
int iconIndex;
int commandId; // Windows command id
@@ -179,8 +179,8 @@ class CCommand0wRet
: public CCommand
{
public:
CCommand0wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand0wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT()>& functor);
QString Execute(const CArgs& args);
@@ -195,8 +195,8 @@ class CCommand1
: public CCommand
{
public:
CCommand1(const string& module, const string& name,
const string& description, const string& example,
CCommand1(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(1, P))>& functor);
QString Execute(const CArgs& args);
@@ -211,8 +211,8 @@ class CCommand1wRet
: public CCommand
{
public:
CCommand1wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand1wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(1, P))>& functor);
QString Execute(const CArgs& args);
@@ -227,8 +227,8 @@ class CCommand2
: public CCommand
{
public:
CCommand2(const string& module, const string& name,
const string& description, const string& example,
CCommand2(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(2, P))>& functor);
QString Execute(const CArgs& args);
@@ -243,8 +243,8 @@ class CCommand2wRet
: public CCommand
{
public:
CCommand2wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand2wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(2, P))>& functor);
QString Execute(const CArgs& args);
@@ -259,8 +259,8 @@ class CCommand3
: public CCommand
{
public:
CCommand3(const string& module, const string& name,
const string& description, const string& example,
CCommand3(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(3, P))>& functor);
QString Execute(const CArgs& args);
@@ -275,8 +275,8 @@ class CCommand3wRet
: public CCommand
{
public:
CCommand3wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand3wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(3, P))>& functor);
QString Execute(const CArgs& args);
@@ -291,8 +291,8 @@ class CCommand4
: public CCommand
{
public:
CCommand4(const string& module, const string& name,
const string& description, const string& example,
CCommand4(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(4, P))>& functor);
QString Execute(const CArgs& args);
@@ -307,8 +307,8 @@ class CCommand4wRet
: public CCommand
{
public:
CCommand4wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand4wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(4, P))>& functor);
QString Execute(const CArgs& args);
@@ -323,8 +323,8 @@ class CCommand5
: public CCommand
{
public:
CCommand5(const string& module, const string& name,
const string& description, const string& example,
CCommand5(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(5, P))>& functor);
QString Execute(const CArgs& args);
@@ -339,8 +339,8 @@ class CCommand6
: public CCommand
{
public:
CCommand6(const string& module, const string& name,
const string& description, const string& example,
CCommand6(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(6, P))>& functor);
QString Execute(const CArgs& args);
@@ -353,8 +353,8 @@ protected:
//////////////////////////////////////////////////////////////////////////
template <typename RT>
CCommand0wRet<RT>::CCommand0wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand0wRet<RT>::CCommand0wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT()>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -373,8 +373,8 @@ QString CCommand0wRet<RT>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(1, typename P)>
CCommand1<LIST(1, P)>::CCommand1(const string& module, const string& name,
const string& description, const string& example,
CCommand1<LIST(1, P)>::CCommand1(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(1, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -410,8 +410,8 @@ QString CCommand1<LIST(1, P)>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(1, typename P), typename RT>
CCommand1wRet<LIST(1, P), RT>::CCommand1wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand1wRet<LIST(1, P), RT>::CCommand1wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(1, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -448,8 +448,8 @@ QString CCommand1wRet<LIST(1, P), RT>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(2, typename P)>
CCommand2<LIST(2, P)>::CCommand2(const string& module, const string& name,
const string& description, const string& example,
CCommand2<LIST(2, P)>::CCommand2(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(2, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -487,8 +487,8 @@ QString CCommand2<LIST(2, P)>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(2, typename P), typename RT>
CCommand2wRet<LIST(2, P), RT>::CCommand2wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand2wRet<LIST(2, P), RT>::CCommand2wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(2, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -527,8 +527,8 @@ QString CCommand2wRet<LIST(2, P), RT>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(3, typename P)>
CCommand3<LIST(3, P)>::CCommand3(const string& module, const string& name,
const string& description, const string& example,
CCommand3<LIST(3, P)>::CCommand3(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(3, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -568,8 +568,8 @@ QString CCommand3<LIST(3, P)>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(3, typename P), typename RT>
CCommand3wRet<LIST(3, P), RT>::CCommand3wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand3wRet<LIST(3, P), RT>::CCommand3wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(3, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -610,8 +610,8 @@ QString CCommand3wRet<LIST(3, P), RT>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(4, typename P)>
CCommand4<LIST(4, P)>::CCommand4(const string& module, const string& name,
const string& description, const string& example,
CCommand4<LIST(4, P)>::CCommand4(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(4, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -654,8 +654,8 @@ QString CCommand4<LIST(4, P)>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(4, typename P), typename RT>
CCommand4wRet<LIST(4, P), RT>::CCommand4wRet(const string& module, const string& name,
const string& description, const string& example,
CCommand4wRet<LIST(4, P), RT>::CCommand4wRet(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<RT(LIST(4, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -699,8 +699,8 @@ QString CCommand4wRet<LIST(4, P), RT>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(5, typename P)>
CCommand5<LIST(5, P)>::CCommand5(const string& module, const string& name,
const string& description, const string& example,
CCommand5<LIST(5, P)>::CCommand5(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(5, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
@@ -745,8 +745,8 @@ QString CCommand5<LIST(5, P)>::Execute(const CCommand::CArgs& args)
//////////////////////////////////////////////////////////////////////////
template <LIST(6, typename P)>
CCommand6<LIST(6, P)>::CCommand6(const string& module, const string& name,
const string& description, const string& example,
CCommand6<LIST(6, P)>::CCommand6(const AZStd::string& module, const AZStd::string& name,
const AZStd::string& description, const AZStd::string& example,
const AZStd::function<void(LIST(6, P))>& functor)
: CCommand(module, name, description, example)
, m_functor(functor)
Code/Editor/Include/IFileUtil.h
+1 -1
View File
@@ -8,8 +8,8 @@
#pragma once
#include "StringUtils.h"
#include "../Include/SandboxAPI.h"
#include <set>
class QWidget;
Code/Editor/Include/IObjectManager.h
+2
View File
@@ -12,8 +12,10 @@
#pragma once
#include <AzCore/PlatformIncl.h>
#include <AzCore/Math/Guid.h>
#include <CryCommon/platform.h>
#include <CryCommon/Cry_Geo.h>
#include <set>
// forward declarations.
class CEntityObject;
Code/Editor/Include/IResourceSelectorHost.h
-135
View File
@@ -1,135 +0,0 @@
/*
* 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
*
*/
#pragma once
// The aim of IResourceSelectorHost is to unify resource selection dialogs in a one
// API that can be reused with plugins. It also makes possible to register new
// resource selectors dynamically, e.g. inside plugins.
//
// Here is how new selectors are created. In your implementation file you add handler function:
//
// #include "IResourceSelectorHost.h"
//
// QString SoundFileSelector(const SResourceSelectorContext& x, const QString& previousValue)
// {
// CMyModalDialog dialog(CWnd::FromHandle(x.parentWindow));
// ...
// return previousValue;
// }
// REGISTER_RESOURCE_SELECTOR("Sound", SoundFileSelector, "Icons/sound_16x16.png")
//
// Here is how it can be invoked directly:
//
// SResourceSelectorContext x;
// x.parentWindow = parent.GetSafeHwnd();
// x.typeName = "Sound";
// string newValue = GetIEditor()->GetResourceSelector()->SelectResource(x, previousValue).c_str();
//
// If you have your own resource selectors in the plugin you will need to run
//
// RegisterModuleResourceSelectors(GetIEditor()->GetResourceSelector())
//
// during plugin initialization.
//
// If you want to be able to pass some custom context to the selector (e.g. source of the information for the
// list of items or something similar) then you can add a poitner argument to your selector function, i.e.:
//
// QString SoundFileSelector(const SResourceSelectorContext& x, const QString& previousValue,
// SoundFileList* list) // your context argument
#include <QString>
class QWidget;
struct SResourceSelectorContext
{
const char* typeName;
// use either parentWidget or parentWindow (not both) until everything porting to QWidget.
QWidget* parentWidget;
unsigned int entityId;
void* contextObject;
SResourceSelectorContext()
: parentWidget(0)
, typeName(0)
, entityId(0)
, contextObject()
{
}
};
// TResourceSelecitonFunction is used to declare handlers for specific types.
//
// For canceled dialogs previousValue should be returned.
typedef QString (* TResourceSelectionFunction)(const SResourceSelectorContext& selectorContext, const QString& previousValue);
typedef QString (* TResourceSelectionFunctionWithContext)(const SResourceSelectorContext& selectorContext, const QString& previousValue, void* contextObject);
struct SStaticResourceSelectorEntry;
// See note at the beginning of the file.
struct IResourceSelectorHost
{
virtual ~IResourceSelectorHost() = default;
virtual QString SelectResource(const SResourceSelectorContext& context, const QString& previousValue) = 0;
virtual const char* ResourceIconPath(const char* typeName) const = 0;
virtual void RegisterResourceSelector(const SStaticResourceSelectorEntry* entry) = 0;
// secondary responsibility of this class is to store global selections
virtual void SetGlobalSelection(const char* resourceType, const char* value) = 0;
virtual const char* GetGlobalSelection(const char* resourceType) const = 0;
};
// ---------------------------------------------------------------------------
#define INTERNAL_RSH_COMBINE_UTIL(A, B) A##B
#define INTERNAL_RSH_COMBINE(A, B) INTERNAL_RSH_COMBINE_UTIL(A, B)
#define REGISTER_RESOURCE_SELECTOR(name, function, icon) \
static SStaticResourceSelectorEntry INTERNAL_RSH_COMBINE(selector_##function, __LINE__)((name), (function), (icon));
struct SStaticResourceSelectorEntry
{
const char* typeName;
TResourceSelectionFunction function;
TResourceSelectionFunctionWithContext functionWithContext;
const char* iconPath;
static SStaticResourceSelectorEntry*& GetFirst() { static SStaticResourceSelectorEntry* first; return first; }
SStaticResourceSelectorEntry* next;
SStaticResourceSelectorEntry(const char* typeName, TResourceSelectionFunction function, const char* icon)
: typeName(typeName)
, function(function)
, functionWithContext()
, iconPath(icon)
{
next = GetFirst();
GetFirst() = this;
}
template<class T>
SStaticResourceSelectorEntry(const char* typeName, QString (*function)(const SResourceSelectorContext&, const QString& previousValue, T * context), const char* icon)
: typeName(typeName)
, function()
, functionWithContext(TResourceSelectionFunctionWithContext(function))
, iconPath(icon)
{
next = GetFirst();
GetFirst() = this;
}
};
inline void RegisterModuleResourceSelectors(IResourceSelectorHost* editorResourceSelector)
{
for (SStaticResourceSelectorEntry* current = SStaticResourceSelectorEntry::GetFirst(); current != 0; current = current->next)
{
editorResourceSelector->RegisterResourceSelector(current);
}
}
Code/Editor/LegacyViewportCameraController.cpp
-537
View File
@@ -1,537 +0,0 @@
/*
* 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 "LegacyViewportCameraController.h"
#include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
#include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
#include <AzFramework/Viewport/ScreenGeometry.h>
#include <AzToolsFramework/Viewport/ViewportMessages.h>
#include <Atom/RPI.Public/ViewportContextBus.h>
#include <Atom/RPI.Public/ViewportContext.h>
#include <IViewSystem.h>
#include <ISystem.h>
#include "CryCommon/MathConversion.h"
#include "SandboxAPI.h"
#include "Settings.h"
namespace SandboxEditor
{
LegacyViewportCameraControllerInstance::LegacyViewportCameraControllerInstance(AzFramework::ViewportId viewportId, LegacyViewportCameraController* controller)
: AzFramework::MultiViewportControllerInstanceInterface<LegacyViewportCameraController>(viewportId, controller)
{
OrbitCameraControlsBus::Handler::BusConnect(viewportId);
}
LegacyViewportCameraControllerInstance::~LegacyViewportCameraControllerInstance()
{
OrbitCameraControlsBus::Handler::BusDisconnect();
}
bool LegacyViewportCameraControllerInstance::JustAltHeld() const
{
return (m_modifiers ^ Qt::AltModifier) == 0;
}
bool LegacyViewportCameraControllerInstance::NoModifierHeld() const
{
return !m_modifiers;
}
bool LegacyViewportCameraControllerInstance::AllowDolly() const
{
return JustAltHeld();
}
bool LegacyViewportCameraControllerInstance::AllowOrbit() const
{
return JustAltHeld();
}
bool LegacyViewportCameraControllerInstance::AllowPan() const
{
// begin pan with alt (inverted movement) or no modifiers
return JustAltHeld() || NoModifierHeld();
}
bool LegacyViewportCameraControllerInstance::InvertPan() const
{
return JustAltHeld();
}
void LegacyViewportCameraControllerInstance::SetOrbitDistance(float orbitDistance)
{
m_orbitDistance = orbitDistance;
}
AZ::RPI::ViewportContextPtr LegacyViewportCameraControllerInstance::GetViewportContext()
{
// This could be cached, if needed
auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
if (!viewportContextManager)
{
return {};
}
return viewportContextManager->GetViewportContextById(GetViewportId());
}
bool LegacyViewportCameraControllerInstance::HandleMouseMove(
int dx, int dy)
{
if (dx == 0 && dy == 0)
{
return false;
}
auto viewportContext = GetViewportContext();
if (!viewportContext)
{
return false;
}
float speedScale = gSettings.cameraMoveSpeed;
if (m_modifiers & Qt::Key_Control)
{
speedScale *= gSettings.cameraFastMoveSpeed;
}
if (m_inMoveMode || m_inOrbitMode || m_inRotateMode || m_inZoomMode)
{
m_totalMouseMoveDelta += AZStd::abs(dx) + AZStd::abs(dy);
}
if ((m_inRotateMode && m_inMoveMode) || m_inZoomMode)
{
Matrix34 m = AZTransformToLYTransform(viewportContext->GetCameraTransform());
Vec3 ydir = m.GetColumn1().GetNormalized();
Vec3 pos = m.GetTranslation();
const float posDelta = 0.2f * dy * speedScale;
pos = pos - ydir * posDelta;
m_orbitDistance = m_orbitDistance + posDelta;
m_orbitDistance = fabs(m_orbitDistance);
m.SetTranslation(pos);
viewportContext->SetCameraTransform(LYTransformToAZTransform(m));
return true;
}
else if (m_inRotateMode)
{
Ang3 angles(dy, 0, dx);
angles = angles * 0.002f * gSettings.cameraRotateSpeed;
if (gSettings.invertYRotation)
{
angles.x = -angles.x;
}
Matrix34 camtm = AZTransformToLYTransform(viewportContext->GetCameraTransform());
Ang3 ypr = CCamera::CreateAnglesYPR(Matrix33(camtm));
ypr.x += angles.z;
ypr.y += angles.x;
ypr.y = AZStd::clamp(ypr.y, -1.5f, 1.5f); // to keep rotation in reasonable range
ypr.z = 0; // to have camera always upward
camtm = Matrix34(CCamera::CreateOrientationYPR(ypr), camtm.GetTranslation());
viewportContext->SetCameraTransform(LYTransformToAZTransform(camtm));
return true;
}
else if (m_inMoveMode)
{
// Slide.
Matrix34 m = AZTransformToLYTransform(viewportContext->GetCameraTransform());
Vec3 xdir = m.GetColumn0().GetNormalized();
Vec3 zdir = m.GetColumn2().GetNormalized();
if (InvertPan())
{
xdir = -xdir;
zdir = -zdir;
}
Vec3 pos = m.GetTranslation();
pos += 0.1f * xdir * dx * speedScale + 0.1f * zdir * dy * speedScale;
m.SetTranslation(pos);
AZ::Transform transform = viewportContext->GetCameraTransform();
transform.SetTranslation(LYVec3ToAZVec3(pos));
viewportContext->SetCameraTransform(transform);
return true;
}
else if (m_inOrbitMode)
{
Ang3 angles(dy, 0, dx);
angles = angles * 0.002f * gSettings.cameraRotateSpeed;
if (gSettings.invertPan)
{
angles.z = -angles.z;
}
Matrix34 m = AZTransformToLYTransform(viewportContext->GetCameraTransform());
Ang3 ypr = CCamera::CreateAnglesYPR(Matrix33(m));
ypr.x += angles.z;
ypr.y = AZStd::clamp(ypr.y, -1.5f, 1.5f); // to keep rotation in reasonable range
ypr.y += angles.x;
Matrix33 rotateTM = CCamera::CreateOrientationYPR(ypr);
Vec3 src = m.GetTranslation();
Vec3 trg(m_orbitTarget.GetX(), m_orbitTarget.GetY(), m_orbitTarget.GetZ());
float fCameraRadius = (trg - src).GetLength();
// Calc new source.
src = trg - rotateTM * Vec3(0, 1, 0) * fCameraRadius;
Matrix34 camTM = rotateTM;
camTM.SetTranslation(src);
viewportContext->SetCameraTransform(LYTransformToAZTransform(camTM));
return true;
}
return false;
}
bool LegacyViewportCameraControllerInstance::HandleMouseWheel(float zDelta)
{
auto viewportContext = GetViewportContext();
if (!viewportContext)
{
return false;
}
Matrix34 m = AZTransformToLYTransform(viewportContext->GetCameraTransform());
const Vec3 ydir = m.GetColumn1().GetNormalized();
Vec3 pos = m.GetTranslation();
const float posDelta = 0.01f * zDelta * gSettings.wheelZoomSpeed;
pos += ydir * posDelta;
m_orbitDistance = m_orbitDistance - posDelta;
m_orbitDistance = fabs(m_orbitDistance);
m.SetTranslation(pos);
viewportContext->SetCameraTransform(LYTransformToAZTransform(m));
return true;
}
bool LegacyViewportCameraControllerInstance::IsKeyDown(Qt::Key key) const
{
return m_pressedKeys.contains(key);
}
Qt::Key LegacyViewportCameraControllerInstance::GetKeyboardKey(const AzFramework::InputChannel& inputChannel)
{
using Key = AzFramework::InputDeviceKeyboard::Key;
const auto& id = inputChannel.GetInputChannelId();
if (id == Key::AlphanumericW)
{
return Qt::Key_W;
}
else if (id == Key::AlphanumericA)
{
return Qt::Key_A;
}
else if (id == Key::AlphanumericS)
{
return Qt::Key_S;
}
else if (id == Key::AlphanumericD)
{
return Qt::Key_D;
}
else if (id == Key::AlphanumericQ)
{
return Qt::Key_Q;
}
else if (id == Key::AlphanumericE)
{
return Qt::Key_E;
}
else if (id == Key::NavigationArrowUp)
{
return Qt::Key_Up;
}
else if (id == Key::NavigationArrowUp)
{
return Qt::Key_Down;
}
else if (id == Key::NavigationArrowUp)
{
return Qt::Key_Left;
}
else if (id == Key::NavigationArrowUp)
{
return Qt::Key_Right;
}
return Qt::Key_unknown;
}
Qt::KeyboardModifier LegacyViewportCameraControllerInstance::GetKeyboardModifier(const AzFramework::InputChannel& inputChannel)
{
using Key = AzFramework::InputDeviceKeyboard::Key;
const auto& id = inputChannel.GetInputChannelId();
if (id == Key::ModifierAltL || id == Key::ModifierAltR)
{
return Qt::KeyboardModifier::AltModifier;
}
if (id == Key::ModifierCtrlL || id == Key::ModifierCtrlR)
{
return Qt::KeyboardModifier::ControlModifier;
}
if (id == Key::ModifierShiftL || id == Key::ModifierShiftR)
{
return Qt::KeyboardModifier::ShiftModifier;
}
return Qt::KeyboardModifier::NoModifier;
}
bool LegacyViewportCameraControllerInstance::HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event)
{
using AzFramework::InputChannel;
using MouseButton = AzFramework::InputDeviceMouse::Button;
const auto& id = event.m_inputChannel.GetInputChannelId();
const auto& state = event.m_inputChannel.GetState();
bool shouldCaptureCursor = m_capturingCursor;
bool shouldConsumeEvent = false;
if (id == AzFramework::InputDeviceMouse::Movement::X || id == AzFramework::InputDeviceMouse::Movement::Y)
{
int dx = 0;
int dy = 0;
if (id == AzFramework::InputDeviceMouse::Movement::X)
{
dx = -aznumeric_cast<int>(event.m_inputChannel.GetValue());
}
else
{
dy = -aznumeric_cast<int>(event.m_inputChannel.GetValue());
}
return HandleMouseMove(dx, dy);
}
else if (id == MouseButton::Left)
{
if (state == InputChannel::State::Began)
{
if (AllowOrbit())
{
AzFramework::CameraState cameraState;
AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus::EventResult(
cameraState, event.m_viewportId,
&AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus::Events::GetCameraState);
m_inOrbitMode = true;
m_orbitTarget = cameraState.m_position + cameraState.m_forward * m_orbitDistance;
shouldConsumeEvent = true;
shouldCaptureCursor = true;
}
}
else if (state == InputChannel::State::Ended)
{
m_inOrbitMode = false;
shouldCaptureCursor = false;
}
}
else if (id == MouseButton::Right)
{
if (state == InputChannel::State::Began)
{
if (AllowDolly())
{
m_inZoomMode = true;
}
else
{
m_inRotateMode = true;
}
shouldCaptureCursor = true;
// Record how much the cursor has been moved to see if we should own the mouse up event.
m_totalMouseMoveDelta = 0;
}
else if (state == InputChannel::State::Ended)
{
m_inZoomMode = false;
m_inRotateMode = false;
// If we've moved the cursor more than a couple pixels, we should eat this mouse up event to prevent the context menu controller from seeing it.
shouldConsumeEvent = m_totalMouseMoveDelta > 2;
shouldCaptureCursor = false;
}
}
else if (id == MouseButton::Middle)
{
if (state == InputChannel::State::Began)
{
if (AllowPan())
{
m_inMoveMode = true;
shouldConsumeEvent = true;
shouldCaptureCursor = true;
}
}
else if (state == InputChannel::State::Ended)
{
m_inMoveMode = false;
shouldCaptureCursor = false;
}
}
else if (auto modifier = GetKeyboardModifier(event.m_inputChannel); modifier != Qt::KeyboardModifier::NoModifier)
{
if (state == InputChannel::State::Ended)
{
m_modifiers &= ~modifier;
}
else
{
m_modifiers |= modifier;
}
}
else if (id == AzFramework::InputDeviceMouse::Movement::Z)
{
if (state == InputChannel::State::Began || state == InputChannel::State::Updated)
{
shouldConsumeEvent = HandleMouseWheel(event.m_inputChannel.GetValue());
}
}
else if (auto key = GetKeyboardKey(event.m_inputChannel); key != Qt::Key_unknown)
{
if (!event.m_inputChannel.IsActive())
{
m_pressedKeys.erase(key);
}
else
{
m_pressedKeys.insert(key);
shouldConsumeEvent = true;
}
}
UpdateCursorCapture(shouldCaptureCursor);
return shouldConsumeEvent;
}
void LegacyViewportCameraControllerInstance::UpdateCursorCapture(bool shouldCaptureCursor)
{
if (m_capturingCursor != shouldCaptureCursor)
{
if (shouldCaptureCursor)
{
AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
GetViewportId(),
&AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::BeginCursorCapture
);
}
else
{
AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
GetViewportId(),
&AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::EndCursorCapture
);
}
m_capturingCursor = shouldCaptureCursor;
}
}
void LegacyViewportCameraControllerInstance::ResetInputChannels()
{
m_modifiers = 0;
m_pressedKeys.clear();
UpdateCursorCapture(false);
m_inRotateMode = m_inMoveMode = m_inOrbitMode = m_inZoomMode = false;
}
void LegacyViewportCameraControllerInstance::UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event)
{
auto viewportContext = GetViewportContext();
if (!viewportContext)
{
return;
}
AZ::Transform transform = viewportContext->GetCameraTransform();
AZ::Vector3 xdir = transform.GetBasisX();
AZ::Vector3 ydir = transform.GetBasisY();
AZ::Vector3 zdir = transform.GetBasisZ();
AZ::Vector3 pos = transform.GetTranslation();
float speedScale = AZStd::GetMin(30.0f * event.m_deltaTime.count(), 20.0f);
// Use the global modifier keys instead of our keymap. It's more reliable.
const bool shiftPressed = m_modifiers & Qt::ShiftModifier;
const bool controlPressed = m_modifiers & Qt::ControlModifier;
speedScale *= gSettings.cameraMoveSpeed;
if (controlPressed)
{
return;
}
if (shiftPressed)
{
speedScale *= gSettings.cameraFastMoveSpeed;
}
bool cameraMoved = false;
if (IsKeyDown(Qt::Key_Up) || IsKeyDown(Qt::Key_W))
{
// move forward
cameraMoved = true;
pos = pos + (speedScale * m_moveSpeed * ydir);
}
if (IsKeyDown(Qt::Key_Down) || IsKeyDown(Qt::Key_S))
{
// move backward
cameraMoved = true;
pos = pos - (speedScale * m_moveSpeed * ydir);
}
if (IsKeyDown(Qt::Key_Left) || IsKeyDown(Qt::Key_A))
{
// move left
cameraMoved = true;
pos = pos - (speedScale * m_moveSpeed * xdir);
}
if (IsKeyDown(Qt::Key_Right) || IsKeyDown(Qt::Key_D))
{
// move right
cameraMoved = true;
pos = pos + (speedScale * m_moveSpeed * xdir);
}
if (IsKeyDown(Qt::Key_E))
{
// move Up
cameraMoved = true;
pos = pos + (speedScale * m_moveSpeed * zdir);
}
if (IsKeyDown(Qt::Key_Q))
{
// move down
cameraMoved = true;
pos = pos - (speedScale * m_moveSpeed * zdir);
}
if (cameraMoved)
{
transform.SetTranslation(pos);
viewportContext->SetCameraTransform(transform);
}
}
} //namespace SandboxEditor
Code/Editor/LegacyViewportCameraController.h
-91
View File
@@ -1,91 +0,0 @@
/*
* 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
*
*/
#pragma once
#include <AzCore/EBus/EBus.h>
#include <AzFramework/Viewport/ViewportId.h>
#include <AzFramework/Viewport/MultiViewportController.h>
#include <AzCore/Math/Vector3.h>
#include <Atom/RPI.Public/Base.h>
#include <QtCore/qnamespace.h>
#include <QPoint>
namespace AzFramework
{
struct ScreenPoint;
}
namespace SandboxEditor
{
class OrbitCameraControls
: public AZ::EBusTraits
{
public:
//////////////////////////////////////////////////////////////////////////
// EBusTraits overrides
static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
using BusIdType = AzFramework::ViewportId;
//////////////////////////////////////////////////////////////////////////
virtual void SetOrbitDistance(float orbitDistance [[maybe_unused]]) {;}
};
using OrbitCameraControlsBus = AZ::EBus<OrbitCameraControls>;
class LegacyViewportCameraControllerInstance;
using LegacyViewportCameraController = AzFramework::MultiViewportController<LegacyViewportCameraControllerInstance>;
class LegacyViewportCameraControllerInstance final
: public AzFramework::MultiViewportControllerInstanceInterface<LegacyViewportCameraController>
, public OrbitCameraControlsBus::Handler
{
public:
LegacyViewportCameraControllerInstance(AzFramework::ViewportId viewport, LegacyViewportCameraController* controller);
~LegacyViewportCameraControllerInstance();
bool HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event) override;
void ResetInputChannels() override;
void UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event) override;
void SetOrbitDistance(float orbitDistance) override;
private:
bool JustAltHeld() const;
bool NoModifierHeld() const;
bool AllowDolly() const;
bool AllowOrbit() const;
bool AllowPan() const;
bool InvertPan() const;
static Qt::KeyboardModifier GetKeyboardModifier(const AzFramework::InputChannel& inputChannel);
static Qt::Key GetKeyboardKey(const AzFramework::InputChannel& inputChannel);
AZ::RPI::ViewportContextPtr GetViewportContext();
bool HandleMouseMove(int dx, int dy);
bool HandleMouseWheel(float zDelta);
bool IsKeyDown(Qt::Key key) const;
void UpdateCursorCapture(bool shouldCaptureCursor);
bool m_inRotateMode = false;
bool m_inMoveMode = false;
bool m_inOrbitMode = false;
bool m_inZoomMode = false;
int m_totalMouseMoveDelta = 0;
float m_orbitDistance = 10.f;
float m_moveSpeed = 1.f;
AZ::Vector3 m_orbitTarget = {};
unsigned int m_modifiers = {};
AZStd::unordered_set<Qt::Key> m_pressedKeys;
bool m_capturingCursor = false;
};
} //namespace SandboxEditor
Code/Editor/LevelFileDialog.cpp
+3 -3
View File
@@ -98,7 +98,7 @@ CLevelFileDialog::CLevelFileDialog(bool openDialog, QWidget* parent)
connect(ui->nameLineEdit, &QLineEdit::textChanged, this, &CLevelFileDialog::OnNameChanged);
}
// reject invalid file names (see CryStringUtils::IsValidFileName)
// reject invalid file names
ui->nameLineEdit->setValidator(new QRegExpValidator(QRegExp("^[a-zA-Z0-9_\\-./]*$"), ui->nameLineEdit));
ReloadTree();
@@ -315,7 +315,7 @@ void CLevelFileDialog::OnNewFolder()
const QString newFolderName = inputDlg.textValue();
const QString newFolderPath = parentFullPath + "/" + newFolderName;
if (!CryStringUtils::IsValidFileName(newFolderName.toUtf8().data()))
if (!AZ::StringFunc::Path::IsValid(newFolderName.toUtf8().data()))
{
QMessageBox box(this);
box.setText(tr("Please enter a single, valid folder name(standard English alphanumeric characters only)"));
@@ -416,7 +416,7 @@ bool CLevelFileDialog::ValidateSaveLevelPath(QString& errorMessage) const
const QString enteredPath = GetEnteredPath();
const QString levelPath = GetLevelPath();
if (!CryStringUtils::IsValidFileName(Path::GetFileName(levelPath).toUtf8().data()))
if (!AZ::StringFunc::Path::IsValid(Path::GetFileName(levelPath).toUtf8().data()))
{
errorMessage = tr("Please enter a valid level name (standard English alphanumeric characters only)");
return false;
Code/Editor/Lib/Tests/IEditorMock.h
-1
View File
@@ -178,7 +178,6 @@ public:
MOCK_CONST_METHOD0(GetEditorConfigSpec, ESystemConfigSpec());
MOCK_CONST_METHOD0(GetEditorConfigPlatform, ESystemConfigPlatform());
MOCK_METHOD0(ReloadTemplates, void());
MOCK_METHOD0(GetResourceSelectorHost, IResourceSelectorHost* ());
MOCK_METHOD1(ShowStatusText, void(bool ));
MOCK_METHOD1(RegisterObjectContextMenuExtension, void(TContextMenuExtensionFunc ));
MOCK_METHOD0(GetEnv, SSystemGlobalEnvironment* ());
Code/Editor/LogFile.cpp
+15 -14
View File
@@ -180,14 +180,14 @@ void CLogFile::FormatLineV(const char * format, va_list argList)
void CLogFile::AboutSystem()
{
char szBuffer[MAX_LOGBUFFER_SIZE];
wchar_t szBufferW[MAX_LOGBUFFER_SIZE];
#if defined(AZ_PLATFORM_WINDOWS) || defined(AZ_PLATFORM_LINUX)
//////////////////////////////////////////////////////////////////////
// Write the system informations to the log
//////////////////////////////////////////////////////////////////////
char szProfileBuffer[128];
char szLanguageBuffer[64];
//char szCPUModel[64];
wchar_t szLanguageBufferW[64];
//wchar_t szCPUModel[64];
MEMORYSTATUS MemoryStatus;
#endif // defined(AZ_PLATFORM_WINDOWS) || defined(AZ_PLATFORM_LINUX)
@@ -201,11 +201,13 @@ void CLogFile::AboutSystem()
//////////////////////////////////////////////////////////////////////
// Get system language
GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_SENGLANGUAGE,
szLanguageBuffer, sizeof(szLanguageBuffer));
GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SENGLANGUAGE,
szLanguageBufferW, sizeof(szLanguageBufferW));
AZStd::string szLanguageBuffer;
AZStd::to_string(szLanguageBuffer, szLanguageBufferW);
// Format and send OS information line
azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, "Current Language: %s ", szLanguageBuffer);
azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, "Current Language: %s ", szLanguageBuffer.c_str());
CryLog("%s", szBuffer);
#else
QLocale locale;
@@ -294,7 +296,8 @@ AZ_POP_DISABLE_WARNING
//////////////////////////////////////////////////////////////////////
str += " (";
GetWindowsDirectory(szBuffer, sizeof(szBuffer));
GetWindowsDirectoryW(szBufferW, sizeof(szBufferW));
AZStd::to_string(szBuffer, MAX_LOGBUFFER_SIZE, szBufferW);
str += szBuffer;
str += ")";
CryLog("%s", str.toUtf8().data());
@@ -381,12 +384,13 @@ AZ_POP_DISABLE_WARNING
#if defined(AZ_PLATFORM_WINDOWS)
EnumDisplaySettings(nullptr, ENUM_CURRENT_SETTINGS, &DisplayConfig);
GetPrivateProfileString("boot.description", "display.drv",
"(Unknown graphics card)", szProfileBuffer, sizeof(szProfileBuffer),
"system.ini");
GetPrivateProfileStringW(L"boot.description", L"display.drv",
L"(Unknown graphics card)", szLanguageBufferW, sizeof(szLanguageBufferW),
L"system.ini");
AZStd::to_string(szLanguageBuffer, szLanguageBufferW);
azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, "Current display mode is %dx%dx%d, %s",
DisplayConfig.dmPelsWidth, DisplayConfig.dmPelsHeight,
DisplayConfig.dmBitsPerPel, szProfileBuffer);
DisplayConfig.dmBitsPerPel, szLanguageBuffer.c_str());
CryLog("%s", szBuffer);
#else
auto screen = QGuiApplication::primaryScreen();
@@ -568,9 +572,6 @@ void CLogFile::OnWriteToConsole(const char* sText, bool bNewLine)
}
if (bNewLine)
{
//str = CString("\r\n") + str.TrimLeft();
//str = CString("\r\n") + str;
//str = CString("\r") + str;
str = QString("\r\n") + str;
str = str.trimmed();
}
Code/Editor/MainWindow.cpp
+1 -1
View File
@@ -1687,7 +1687,7 @@ void MainWindow::OnUpdateConnectionStatus()
status = tr("Pending Jobs : %1 Failed Jobs : %2").arg(m_connectionListener->GetJobsCount()).arg(failureCount);
statusBar->SetItem(QtUtil::ToQString("connection"), status, tooltip, icon);
statusBar->SetItem("connection", status, tooltip, icon);
if (m_showAPDisconnectDialog && m_connectionListener->GetState() != EConnectionState::Connected)
{
Code/Editor/Objects/ObjectLoader.h
+2
View File
@@ -15,6 +15,8 @@
#include "Util/GuidUtil.h"
#include "ErrorReport.h"
#include <set>
class CPakFile;
class CErrorRecord;
struct IObjectManager;
Code/Editor/Platform/Windows/Util/Mailer_Windows.cpp
+3 -3
View File
@@ -28,7 +28,7 @@ bool CMailer::SendMail(const char* subject,
GetCurrentDirectoryW(sizeof(dir), dir);
// Load MAPI dll
HMODULE hMAPILib = LoadLibraryA("MAPI32.DLL");
HMODULE hMAPILib = LoadLibraryW(L"MAPI32.DLL");
LPMAPISENDMAIL lpfnMAPISendMail = (LPMAPISENDMAIL) GetProcAddress(hMAPILib, "MAPISendMail");
int numRecipients = (int)_recipients.size();
@@ -60,11 +60,11 @@ bool CMailer::SendMail(const char* subject,
// Handle Recipients
MapiRecipDesc* recipients = new MapiRecipDesc[numRecipients];
std::vector<string> addresses;
std::vector<AZStd::string> addresses;
addresses.resize(numRecipients);
for (i = 0; i < numRecipients; i++)
{
addresses[i] = string("SMTP:") + _recipients[i];
addresses[i] = AZStd::string("SMTP:") + _recipients[i];
}
for (i = 0; i < numRecipients; i++)
Code/Editor/PluginManager.cpp
+11 -15
View File
@@ -17,9 +17,8 @@
// Editor
#include "Include/IPlugin.h"
using TPfnCreatePluginInstance = IPlugin *(*)(PLUGIN_INIT_PARAM *pInitParam);
using TPfnQueryPluginSettings = void (*)(SPluginSettings &);
using TPfnCreatePluginInstance = IPlugin* (*)(PLUGIN_INIT_PARAM* pInitParam);
using TPfnQueryPluginSettings = void (*)(SPluginSettings&);
CPluginManager::CPluginManager()
{
@@ -126,8 +125,8 @@ namespace
bool CPluginManager::LoadPlugins(const char* pPathWithMask)
{
QString strPath = QtUtil::ToQString(PathUtil::GetPath(pPathWithMask));
QString strMask = QString::fromUtf8(PathUtil::GetFile(pPathWithMask));
QString strPath = PathUtil::GetPath(pPathWithMask).c_str();
QString strMask = PathUtil::GetFile(pPathWithMask);
CLogFile::WriteLine("[Plugin Manager] Loading plugins...");
@@ -155,7 +154,7 @@ bool CPluginManager::LoadPlugins(const char* pPathWithMask)
}
#endif
}
if (plugins.size() == 0)
if (plugins.empty())
{
CLogFile::FormatLine("[Plugin Manager] Cannot find any plugins in plugin directory '%s'", strPath.toUtf8().data());
return false;
@@ -269,13 +268,13 @@ void CPluginManager::RegisterPlugin(QLibrary* dllHandle, IPlugin* pPlugin)
IPlugin* CPluginManager::GetPluginByGUID(const char* pGUID)
{
for (auto it = m_plugins.begin(); it != m_plugins.end(); ++it)
for (const SPluginEntry& pluginEntry : m_plugins)
{
const char* pPluginGuid = it->pPlugin->GetPluginGUID();
const char* pPluginGuid = pluginEntry.pPlugin->GetPluginGUID();
if (pPluginGuid && !strcmp(pPluginGuid, pGUID))
{
return it->pPlugin;
return pluginEntry.pPlugin;
}
}
@@ -332,14 +331,11 @@ IUIEvent* CPluginManager::GetEventByIDAndPluginID(uint8 aPluginID, uint8 aEventI
bool CPluginManager::CanAllPluginsExitNow()
{
for (auto it = m_plugins.begin(); it != m_plugins.end(); ++it)
for (const SPluginEntry& pluginEntry : m_plugins)
{
if (it->pPlugin)
if (pluginEntry.pPlugin && !pluginEntry.pPlugin->CanExitNow())
{
if (!it->pPlugin->CanExitNow())
{
return false;
}
return false;
}
}
Code/Editor/Plugins/ComponentEntityEditorPlugin/ComponentEntityEditorPlugin.cpp
-3
View File
@@ -9,7 +9,6 @@
#include "ComponentEntityEditorPlugin.h"
#include <LyViewPaneNames.h>
#include "IResourceSelectorHost.h"
#include "UI/QComponentEntityEditorMainWindow.h"
#include "UI/QComponentEntityEditorOutlinerWindow.h"
@@ -180,8 +179,6 @@ ComponentEntityEditorPlugin::ComponentEntityEditorPlugin([[maybe_unused]] IEdito
RegisterViewPane<SliceRelationshipWidget>(LyViewPane::SliceRelationships, LyViewPane::CategoryTools, options);
}
RegisterModuleResourceSelectors(GetIEditor()->GetResourceSelectorHost());
ComponentEntityEditorPluginInternal::RegisterSandboxObjects();
// Check for common mistakes in component declarations
Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
+35 -76
View File
@@ -82,7 +82,6 @@
#include <Editor/QtViewPaneManager.h>
#include <Editor/EditorViewportSettings.h>
#include <Editor/Util/PathUtil.h>
#include <IResourceSelectorHost.h>
#include "CryEdit.h"
#include "Undo/Undo.h"
@@ -1387,16 +1386,6 @@ AZStd::string SandboxIntegrationManager::GetLevelName()
return AZStd::string(GetIEditor()->GetGameEngine()->GetLevelName().toUtf8().constData());
}
AZStd::string SandboxIntegrationManager::SelectResource(const AZStd::string& resourceType, const AZStd::string& previousValue)
{
SResourceSelectorContext context;
context.parentWidget = GetMainWindow();
context.typeName = resourceType.c_str();
QString resource = GetEditor()->GetResourceSelectorHost()->SelectResource(context, previousValue.c_str());
return AZStd::string(resource.toUtf8().constData());
}
void SandboxIntegrationManager::OnContextReset()
{
// Deselect everything.
@@ -1452,7 +1441,7 @@ void SandboxIntegrationManager::ContextMenu_NewEntity()
if (view)
{
const QPoint viewPoint(m_contextMenuViewPoint.GetX(), m_contextMenuViewPoint.GetY());
worldPosition = LYVec3ToAZVec3(view->SnapToGrid(view->ViewToWorld(viewPoint)));
worldPosition = view->GetHitLocation(viewPoint);
}
CreateNewEntityAtPosition(worldPosition);
@@ -1704,74 +1693,44 @@ void SandboxIntegrationManager::GoToEntitiesInViewports(const AzToolsFramework::
return;
}
if (SandboxEditor::UsingNewCameraSystem())
const AZ::Aabb aabb = AZStd::accumulate(
AZStd::begin(entityIds), AZStd::end(entityIds), AZ::Aabb::CreateNull(), [](AZ::Aabb acc, const AZ::EntityId entityId) {
const AZ::Aabb aabb = AzFramework::CalculateEntityWorldBoundsUnion(AzToolsFramework::GetEntityById(entityId));
acc.AddAabb(aabb);
return acc;
});
float radius;
AZ::Vector3 center;
aabb.GetAsSphere(center, radius);
// minimum center size is 40cm
const float minSelectionRadius = 0.4f;
const float selectionSize = AZ::GetMax(minSelectionRadius, radius);
auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
const int viewCount = GetIEditor()->GetViewManager()->GetViewCount(); // legacy call
for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)
{
const AZ::Aabb aabb = AZStd::accumulate(
AZStd::begin(entityIds), AZStd::end(entityIds), AZ::Aabb::CreateNull(), [](AZ::Aabb acc, const AZ::EntityId entityId) {
const AZ::Aabb aabb = AzFramework::CalculateEntityWorldBoundsUnion(AzToolsFramework::GetEntityById(entityId));
acc.AddAabb(aabb);
return acc;
});
float radius;
AZ::Vector3 center;
aabb.GetAsSphere(center, radius);
// minimum center size is 40cm
const float minSelectionRadius = 0.4f;
const float selectionSize = AZ::GetMax(minSelectionRadius, radius);
auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
const int viewCount = GetIEditor()->GetViewManager()->GetViewCount(); // legacy call
for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)
if (auto viewportContext = viewportContextManager->GetViewportContextById(viewIndex))
{
if (auto viewportContext = viewportContextManager->GetViewportContextById(viewIndex))
{
const AZ::Transform cameraTransform = viewportContext->GetCameraTransform();
const AZ::Vector3 forward = (center - cameraTransform.GetTranslation()).GetNormalized();
const AZ::Transform cameraTransform = viewportContext->GetCameraTransform();
const AZ::Vector3 forward = (center - cameraTransform.GetTranslation()).GetNormalized();
// move camera 25% further back than required
const float centerScale = 1.25f;
// compute new camera transform
const float fov = AzFramework::RetrieveFov(viewportContext->GetCameraProjectionMatrix());
const float fovScale = (1.0f / AZStd::tan(fov * 0.5f));
const float distanceToLookAt = selectionSize * fovScale * centerScale;
const AZ::Transform nextCameraTransform =
AZ::Transform::CreateLookAt(aabb.GetCenter() - (forward * distanceToLookAt), aabb.GetCenter());
// move camera 25% further back than required
const float centerScale = 1.25f;
// compute new camera transform
const float fov = AzFramework::RetrieveFov(viewportContext->GetCameraProjectionMatrix());
const float fovScale = (1.0f / AZStd::tan(fov * 0.5f));
const float distanceToLookAt = selectionSize * fovScale * centerScale;
const AZ::Transform nextCameraTransform =
AZ::Transform::CreateLookAt(aabb.GetCenter() - (forward * distanceToLookAt), aabb.GetCenter());
AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
viewportContext->GetId(),
&AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::InterpolateToTransform, nextCameraTransform,
distanceToLookAt);
}
}
}
else
{
AABB selectionBounds;
selectionBounds.Reset();
bool entitiesAvailableForGoTo = false;
for (const AZ::EntityId& entityId : entityIds)
{
if (CollectEntityBoundingBoxesForZoom(entityId, selectionBounds))
{
entitiesAvailableForGoTo = true;
}
}
if (entitiesAvailableForGoTo)
{
int numViews = GetIEditor()->GetViewManager()->GetViewCount();
for (int viewIndex = 0; viewIndex < numViews; ++viewIndex)
{
CViewport* viewport = GetIEditor()->GetViewManager()->GetView(viewIndex);
if (viewport)
{
viewport->CenterOnAABB(selectionBounds);
}
}
AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
viewportContext->GetId(),
&AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::InterpolateToTransform, nextCameraTransform,
distanceToLookAt);
}
}
}
Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.h
-1
View File
@@ -158,7 +158,6 @@ private:
void LaunchLuaEditor(const char* files) override;
bool IsLevelDocumentOpen() override;
AZStd::string GetLevelName() override;
AZStd::string SelectResource(const AZStd::string& resourceType, const AZStd::string& previousValue) override;
void OpenPinnedInspector(const AzToolsFramework::EntityIdSet& entities) override;
void ClosePinnedInspector(AzToolsFramework::EntityPropertyEditor* editor) override;
void GoToSelectedOrHighlightedEntitiesInViewports() override;
Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerTreeView.cpp
+6 -77
View File
@@ -20,7 +20,7 @@
#include <QMouseEvent>
OutlinerTreeView::OutlinerTreeView(QWidget* pParent)
: QTreeView(pParent)
: AzQtComponents::StyledTreeView(pParent)
, m_queuedMouseEvent(nullptr)
, m_draggingUnselectedItem(false)
{
@@ -135,16 +135,12 @@ void OutlinerTreeView::startDrag(Qt::DropActions supportedActions)
if (!selectionModel()->isSelected(index))
{
startCustomDrag({ index }, supportedActions);
StartCustomDrag({ index }, supportedActions);
return;
}
}
if (!selectionModel()->selectedIndexes().empty())
{
startCustomDrag(selectionModel()->selectedIndexes(), supportedActions);
return;
}
StyledTreeView::startDrag(supportedActions);
}
void OutlinerTreeView::dragMoveEvent(QDragMoveEvent* event)
@@ -336,14 +332,14 @@ void OutlinerTreeView::processQueuedMousePressedEvent(QMouseEvent* event)
QTreeView::mousePressEvent(&mousePressedEvent);
}
void OutlinerTreeView::startCustomDrag(const QModelIndexList& indexList, Qt::DropActions supportedActions)
void OutlinerTreeView::StartCustomDrag(const QModelIndexList& indexList, Qt::DropActions supportedActions)
{
m_draggingUnselectedItem = true;
//sort by container entity depth and order in hierarchy for proper drag image and drop order
QModelIndexList indexListSorted = indexList;
AZStd::unordered_map<AZ::EntityId, AZStd::list<AZ::u64>> locations;
for (auto index : indexListSorted)
for (const auto& index : indexListSorted)
{
AZ::EntityId entityId(index.data(OutlinerListModel::EntityIdRole).value<AZ::u64>());
AzToolsFramework::GetEntityLocationInHierarchy(entityId, locations[entityId]);
@@ -356,74 +352,7 @@ void OutlinerTreeView::startCustomDrag(const QModelIndexList& indexList, Qt::Dro
return AZStd::lexicographical_compare(locationsE1.begin(), locationsE1.end(), locationsE2.begin(), locationsE2.end());
});
//get the data for the unselected item(s)
QMimeData* mimeData = model()->mimeData(indexListSorted);
if (mimeData)
{
//initiate drag/drop for the item
QDrag* drag = new QDrag(this);
drag->setPixmap(QPixmap::fromImage(createDragImage(indexListSorted)));
drag->setMimeData(mimeData);
Qt::DropAction defDropAction = Qt::IgnoreAction;
if (defaultDropAction() != Qt::IgnoreAction && (supportedActions & defaultDropAction()))
{
defDropAction = defaultDropAction();
}
else if (supportedActions & Qt::CopyAction && dragDropMode() != QAbstractItemView::InternalMove)
{
defDropAction = Qt::CopyAction;
}
drag->exec(supportedActions, defDropAction);
}
}
QImage OutlinerTreeView::createDragImage(const QModelIndexList& indexList)
{
//generate a drag image of the item icon and text, normally done internally, and inaccessible
QRect rect(0, 0, 0, 0);
for (auto index : indexList)
{
if (index.column() != 0)
{
continue;
}
QRect itemRect = visualRect(index);
rect.setHeight(rect.height() + itemRect.height());
rect.setWidth(AZStd::GetMax(rect.width(), itemRect.width()));
}
QImage dragImage(rect.size(), QImage::Format_ARGB32_Premultiplied);
QPainter dragPainter(&dragImage);
dragPainter.setCompositionMode(QPainter::CompositionMode_Source);
dragPainter.fillRect(dragImage.rect(), Qt::transparent);
dragPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
dragPainter.setOpacity(0.35f);
dragPainter.fillRect(rect, QColor("#222222"));
dragPainter.setOpacity(1.0f);
int imageY = 0;
for (auto index : indexList)
{
if (index.column() != 0)
{
continue;
}
QRect itemRect = visualRect(index);
dragPainter.drawPixmap(QPoint(0, imageY),
model()->data(index, Qt::DecorationRole).value<QIcon>().pixmap(QSize(16, 16)));
dragPainter.setPen(
model()->data(index, Qt::ForegroundRole).value<QBrush>().color());
dragPainter.setFont(
font());
dragPainter.drawText(QRect(20, imageY, rect.width() - 20, rect.height()),
model()->data(index, Qt::DisplayRole).value<QString>());
imageY += itemRect.height();
}
dragPainter.end();
return dragImage;
StyledTreeView::StartCustomDrag(indexListSorted, supportedActions);
}
#include <UI/Outliner/moc_OutlinerTreeView.cpp>
Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerTreeView.hxx
+4 -5
View File
@@ -15,7 +15,8 @@
#include <QBasicTimer>
#include <QEvent>
#include <QTreeView>
#include <AzQtComponents/Components/Widgets/TreeView.h>
#endif
#pragma once
@@ -31,7 +32,7 @@ class OutlinerTreeViewModel;
//! allow for dragging and dropping of entities from the outliner into the property editor
//! of other entities. If the selection updates instantly, this would never be possible.
class OutlinerTreeView
: public QTreeView
: public AzQtComponents::StyledTreeView
{
Q_OBJECT;
public:
@@ -66,9 +67,7 @@ private:
void processQueuedMousePressedEvent(QMouseEvent* event);
void startCustomDrag(const QModelIndexList& indexList, Qt::DropActions supportedActions);
QImage createDragImage(const QModelIndexList& indexList);
void StartCustomDrag(const QModelIndexList& indexList, Qt::DropActions supportedActions) override;
void DrawLayerUI(QPainter* painter, const QRect& rect, const QModelIndex& index) const;
Code/Editor/Plugins/EditorAssetImporter/AssetImporterPlugin.h
+2 -2
View File
@@ -41,7 +41,7 @@ public:
return m_editor;
}
const string& GetToolName() const
const AZStd::string& GetToolName() const
{
return m_toolName;
}
@@ -88,7 +88,7 @@ private:
IEditor* const m_editor;
// Tool name
string m_toolName;
AZStd::string m_toolName;
// Context provider for the Asset Browser
AZ::AssetBrowserContextProvider m_assetBrowserContextProvider;
Code/Editor/Plugins/EditorCommon/DrawingPrimitives/Ruler.cpp
+1
View File
@@ -12,6 +12,7 @@
#include <QPainter>
#include <QPalette>
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/std/algorithm.h>
namespace DrawingPrimitives
{
Code/Editor/Plugins/FFMPEGPlugin/FFMPEGPlugin.cpp
-2
View File
@@ -8,8 +8,6 @@
#include "FFMPEGPlugin.h"
#include "CryString.h"
typedef CryStringT<char> string;
#include "Include/ICommandManager.h"
#include "Util/PathUtil.h"
Code/Editor/Plugins/PerforcePlugin/PerforceSourceControl.cpp
+4 -4
View File
@@ -22,7 +22,7 @@
namespace
{
CryCriticalSection g_cPerforceValues;
AZStd::mutex g_cPerforceValues;
}
////////////////////////////////////////////////////////////
@@ -30,9 +30,9 @@ ULONG STDMETHODCALLTYPE CPerforceSourceControl::Release()
{
if ((--m_ref) == 0)
{
g_cPerforceValues.Lock();
g_cPerforceValues.lock();
delete this;
g_cPerforceValues.Unlock();
g_cPerforceValues.unlock();
return 0;
}
else
@@ -56,7 +56,7 @@ void CPerforceSourceControl::ShowSettings()
void CPerforceSourceControl::SetSourceControlState(SourceControlState state)
{
CryAutoLock<CryCriticalSection> lock(g_cPerforceValues);
AZStd::scoped_lock lock(g_cPerforceValues);
switch (state)
{
Code/Editor/Plugins/ProjectSettingsTool/ProjectSettingsContainer.cpp
+1
View File
@@ -8,6 +8,7 @@
#include "ProjectSettingsContainer.h"
#include <AzCore/IO/SystemFile.h>
#include <AzCore/JSON/prettywriter.h>
#include <AzCore/JSON/stringbuffer.h>
#include <AzCore/XML/rapidxml_print.h>
Code/Editor/ProcessInfo.cpp
+1 -1
View File
@@ -41,7 +41,7 @@ void LoadPSApi()
{
if (!g_hPSAPI)
{
g_hPSAPI = LoadLibraryA("psapi.dll");
g_hPSAPI = LoadLibraryW(L"psapi.dll");
if (g_hPSAPI)
{
Code/Editor/QtUtil.h
+1 -25
View File
@@ -10,8 +10,7 @@
#pragma once
#include <QString>
#include <CryString.h>
#include "UnicodeFunctions.h"
#include <CryCommon/StlUtils.h>
#include <QApplication>
#include <QDropEvent>
@@ -36,29 +35,6 @@ public:
namespace QtUtil
{
// From QString to CryString
inline CryStringT<char> ToString(const QString& str)
{
return Unicode::Convert<CryStringT<char> >(str);
}
// From CryString to QString
inline QString ToQString(const CryStringT<char>& str)
{
return Unicode::Convert<QString>(str);
}
// From const char * to QString
inline QString ToQString(const char* str, size_t len = -1)
{
if (len == -1)
{
len = strlen(str);
}
return Unicode::Convert<QString>(str, str + len);
}
// Replacement for CString::trimRight()
inline QString trimRight(const QString& str)
{
// We prepend a char, so that the left doesn't get trimmed, then we remove it after trimming
Code/Editor/QuickAccessBar.cpp
+3 -3
View File
@@ -68,12 +68,12 @@ void CQuickAccessBar::OnInitDialog()
// Add console variables & commands.
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
std::vector<const char*> cmds;
AZStd::vector<AZStd::string_view> cmds;
cmds.resize(console->GetNumVars());
size_t cmdCount = console->GetSortedVars(&cmds[0], cmds.size());
size_t cmdCount = console->GetSortedVars(cmds);
for (int i = 0; i < cmdCount; ++i)
{
m_model->setStringList(m_model->stringList() += cmds[i]);
m_model->setStringList(m_model->stringList() += cmds[i].data());
}
}
Code/Editor/ResourceSelectorHost.cpp
-167
View File
@@ -1,167 +0,0 @@
/*
* 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 "EditorDefs.h"
#include "ResourceSelectorHost.h"
// Qt
#include <QMessageBox>
#include <QString>
// AzToolsFramework
#include <AzToolsFramework/API/ToolsApplicationAPI.h>
#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
class CResourceSelectorHost
: public IResourceSelectorHost
{
public:
CResourceSelectorHost()
{
RegisterModuleResourceSelectors(this);
}
QString SelectResource(const SResourceSelectorContext& context, const QString& previousValue) override
{
if (!context.typeName)
{
assert(false && "SResourceSelectorContext::typeName is not specified");
return QString();
}
TTypeMap::iterator it = m_typeMap.find(context.typeName);
if (it == m_typeMap.end())
{
QMessageBox::critical(QApplication::activeWindow(), QString(), QObject::tr("No Resource Selector is registered for resource type \"%1\"").arg(context.typeName));
return previousValue;
}
QString result = previousValue;
if (it->second->function)
{
result = it->second->function(context, previousValue);
}
else if (it->second->functionWithContext)
{
result = it->second->functionWithContext(context, previousValue, context.contextObject);
}
return result;
}
const char* ResourceIconPath(const char* typeName) const override
{
TTypeMap::const_iterator it = m_typeMap.find(typeName);
if (it != m_typeMap.end())
{
return it->second->iconPath;
}
return "";
}
void RegisterResourceSelector(const SStaticResourceSelectorEntry* entry) override
{
m_typeMap[entry->typeName] = entry;
}
void SetGlobalSelection(const char* resourceType, const char* value) override
{
if (!resourceType)
{
return;
}
if (!value)
{
return;
}
m_globallySelectedResources[resourceType] = value;
}
const char* GetGlobalSelection(const char* resourceType) const override
{
if (!resourceType)
{
return "";
}
auto it = m_globallySelectedResources.find(resourceType);
if (it != m_globallySelectedResources.end())
{
return it->second.c_str();
}
return "";
}
private:
using TTypeMap = std::map<string, const SStaticResourceSelectorEntry *, stl::less_stricmp<string>>;
TTypeMap m_typeMap;
std::map<string, string> m_globallySelectedResources;
};
// ---------------------------------------------------------------------------
IResourceSelectorHost* CreateResourceSelectorHost()
{
return new CResourceSelectorHost();
}
// ---------------------------------------------------------------------------
QString SoundFileSelector([[maybe_unused]] const SResourceSelectorContext& x, const QString& previousValue)
{
AssetSelectionModel selection = AssetSelectionModel::AssetTypeSelection("Audio");
AzToolsFramework::EditorRequests::Bus::Broadcast(&AzToolsFramework::EditorRequests::BrowseForAssets, selection);
if (selection.IsValid())
{
return Path::FullPathToGamePath(QString(selection.GetResult()->GetFullPath().c_str()));
}
else
{
return Path::FullPathToGamePath(previousValue);
}
}
REGISTER_RESOURCE_SELECTOR("Sound", SoundFileSelector, "")
// ---------------------------------------------------------------------------
QString ModelFileSelector([[maybe_unused]] const SResourceSelectorContext& x, const QString& previousValue)
{
AssetSelectionModel selection = AssetSelectionModel::AssetGroupSelection("Geometry");
AzToolsFramework::EditorRequests::Bus::Broadcast(&AzToolsFramework::EditorRequests::BrowseForAssets, selection);
if (selection.IsValid())
{
return Path::FullPathToGamePath(QString(selection.GetResult()->GetFullPath().c_str()));
}
else
{
return Path::FullPathToGamePath(previousValue);
}
}
REGISTER_RESOURCE_SELECTOR("Model", ModelFileSelector, "")
// ---------------------------------------------------------------------------
QString GeomCacheFileSelector([[maybe_unused]] const SResourceSelectorContext& x, const QString& previousValue)
{
AssetSelectionModel selection = AssetSelectionModel::AssetTypeSelection("Geom Cache");
AzToolsFramework::EditorRequests::Bus::Broadcast(&AzToolsFramework::EditorRequests::BrowseForAssets, selection);
if (selection.IsValid())
{
return Path::FullPathToGamePath(QString(selection.GetResult()->GetFullPath().c_str()));
}
else
{
return Path::FullPathToGamePath(previousValue);
}
}
REGISTER_RESOURCE_SELECTOR("GeomCache", GeomCacheFileSelector, "")
Code/Editor/ResourceSelectorHost.h
-18
View File
@@ -1,18 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_RESOURCESELECTORHOST_H
#define CRYINCLUDE_EDITOR_RESOURCESELECTORHOST_H
#pragma once
#include "IResourceSelectorHost.h"
IResourceSelectorHost* CreateResourceSelectorHost();
#endif // CRYINCLUDE_EDITOR_RESOURCESELECTORHOST_H
Code/Editor/SelectSequenceDialog.cpp
+1 -1
View File
@@ -37,7 +37,7 @@ CSelectSequenceDialog::GetItems(std::vector<SItem>& outItems)
{
IAnimSequence* pSeq = pMovieSys->GetSequence(i);
SItem item;
string fullname = pSeq->GetName();
AZStd::string fullname = pSeq->GetName();
item.name = fullname.c_str();
outItems.push_back(item);
}
Code/Editor/Settings.cpp
-16
View File
@@ -661,22 +661,6 @@ void SEditorSettings::Save()
//////////////////////////////////////////////////////////////////////////
SaveValue("Settings\\Slices", "DynamicByDefault", sliceSettings.dynamicByDefault);
/*
//////////////////////////////////////////////////////////////////////////
// Save paths.
//////////////////////////////////////////////////////////////////////////
for (int id = 0; id < EDITOR_PATH_LAST; id++)
{
for (int i = 0; i < searchPaths[id].size(); i++)
{
CString path = searchPaths[id][i];
CString key;
key.Format( "Paths","Path_%.2d_%.2d",id,i );
SaveValue( "Paths",key,path );
}
}
*/
s_editorSettings()->sync();
// --- Settings Registry values
Code/Editor/SettingsManager.cpp
+6 -6
View File
@@ -607,7 +607,7 @@ void CSettingsManager::SerializeCVars(XmlNodeRef& node, bool bLoad)
int nCurrentVariable(0);
IConsole* piConsole(nullptr);
ICVar* piVariable(nullptr);
std::vector<char*> cszVariableNames;
AZStd::vector<AZStd::string_view> cszVariableNames;
char* szKey(nullptr);
char* szValue(nullptr);
@@ -660,9 +660,9 @@ void CSettingsManager::SerializeCVars(XmlNodeRef& node, bool bLoad)
XmlNodeRef cvarsNode = XmlHelpers::CreateXmlNode(CVARS_NODE);
nNumberOfVariables = piConsole->GetNumVisibleVars();
cszVariableNames.resize(nNumberOfVariables, nullptr);
cszVariableNames.resize(nNumberOfVariables);
if (piConsole->GetSortedVars((const char**)&cszVariableNames.front(), nNumberOfVariables, nullptr) != nNumberOfVariables)
if (piConsole->GetSortedVars(cszVariableNames) != nNumberOfVariables)
{
assert(false);
return;
@@ -670,12 +670,12 @@ void CSettingsManager::SerializeCVars(XmlNodeRef& node, bool bLoad)
for (nCurrentVariable = 0; nCurrentVariable < cszVariableNames.size(); ++nCurrentVariable)
{
if (_stricmp(cszVariableNames[nCurrentVariable], "_TestFormatMessage") == 0)
if (_stricmp(cszVariableNames[nCurrentVariable].data(), "_TestFormatMessage") == 0)
{
continue;
}
piVariable = piConsole->GetCVar(cszVariableNames[nCurrentVariable]);
piVariable = piConsole->GetCVar(cszVariableNames[nCurrentVariable].data());
if (!piVariable)
{
assert(false);
@@ -683,7 +683,7 @@ void CSettingsManager::SerializeCVars(XmlNodeRef& node, bool bLoad)
}
newCVarNode = XmlHelpers::CreateXmlNode(CVAR_NODE);
newCVarNode->setAttr(cszVariableNames[nCurrentVariable], piVariable->GetString());
newCVarNode->setAttr(cszVariableNames[nCurrentVariable].data(), piVariable->GetString());
cvarsNode->addChild(newCVarNode);
}
Code/Editor/ToolBox.cpp
+4 -4
View File
@@ -379,7 +379,7 @@ void CToolBoxManager::Load(QString xmlpath, AmazonToolbar* pToolbar, bool bToolb
AZ::IO::FixedMaxPathString engineRoot = AZ::Utils::GetEnginePath();
QDir engineDir = !engineRoot.empty() ? QDir(QString(engineRoot.c_str())) : QDir::current();
string enginePath = PathUtil::AddSlash(engineDir.absolutePath().toUtf8().data());
AZStd::string enginePath = PathUtil::AddSlash(engineDir.absolutePath().toUtf8().data());
for (int i = 0; i < toolBoxNode->getChildCount(); ++i)
{
@@ -405,11 +405,11 @@ void CToolBoxManager::Load(QString xmlpath, AmazonToolbar* pToolbar, bool bToolb
continue;
}
string shelfPath = PathUtil::GetParentDirectory(xmlpath.toUtf8().data());
string fullIconPath = enginePath + PathUtil::AddSlash(shelfPath.c_str());
AZStd::string shelfPath = PathUtil::GetParentDirectory(xmlpath.toUtf8().data());
AZStd::string fullIconPath = enginePath + PathUtil::AddSlash(shelfPath.c_str());
fullIconPath.append(iconPath.toUtf8().data());
pMacro->SetIconPath(fullIconPath);
pMacro->SetIconPath(fullIconPath.c_str());
QString toolTip(macroNode->getAttr("tooltip"));
pMacro->action()->setToolTip(toolTip);
Code/Editor/ToolsConfigPage.cpp
+3 -3
View File
@@ -818,12 +818,12 @@ void CToolsConfigPage::FillConsoleCmds()
{
QStringList commands;
IConsole* console = GetIEditor()->GetSystem()->GetIConsole();
std::vector<const char*> cmds;
AZStd::vector<AZStd::string_view> cmds;
cmds.resize(console->GetNumVars());
size_t cmdCount = console->GetSortedVars(&cmds[0], cmds.size());
size_t cmdCount = console->GetSortedVars(cmds);
for (int i = 0; i < cmdCount; ++i)
{
commands.push_back(cmds[i]);
commands.push_back(cmds[i].data());
}
m_completionModel->setStringList(commands);
}
Code/Editor/TrackView/CommentKeyUIControls.cpp
+1 -1
View File
@@ -52,7 +52,7 @@ public:
CFileUtil::ScanDirectory((Path::GetEditingGameDataFolder() + "/Fonts/").c_str(), "*.xml", fa, true);
for (size_t i = 0; i < fa.size(); ++i)
{
string name = fa[i].filename.toUtf8().data();
AZStd::string name = fa[i].filename.toUtf8().data();
PathUtil::RemoveExtension(name);
mv_font->AddEnumItem(name.c_str(), name.c_str());
}
Code/Editor/TrackView/CommentNodeAnimator.cpp
+1 -1
View File
@@ -92,7 +92,7 @@ void CCommentNodeAnimator::AnimateCommentTextTrack(CTrackViewTrack* pTrack, cons
if (commentKey.m_duration > 0 && ac.time < keyHandle.GetTime() + commentKey.m_duration)
{
m_commentContext.m_strComment = commentKey.m_strComment;
cry_strcpy(m_commentContext.m_strFont, commentKey.m_strFont.c_str());
azstrcpy(m_commentContext.m_strFont, AZ_ARRAY_SIZE(m_commentContext.m_strFont), commentKey.m_strFont.c_str());
m_commentContext.m_color = commentKey.m_color;
m_commentContext.m_align = commentKey.m_align;
m_commentContext.m_size = commentKey.m_size;
Code/Editor/TrackView/SequenceKeyUIControls.cpp
+1 -1
View File
@@ -91,7 +91,7 @@ bool CSequenceKeyUIControls::OnKeySelectionChange(CTrackViewKeyBundle& selectedK
bool bNotParent = !bNotMe || pCurrentSequence->IsAncestorOf(pSequence) == false;
if (bNotMe && bNotParent)
{
string seqName = pCurrentSequence->GetName();
AZStd::string seqName = pCurrentSequence->GetName();
QString ownerIdString = CTrackViewDialog::GetEntityIdAsString(pCurrentSequence->GetSequenceComponentEntityId());
mv_sequence->AddEnumItem(seqName.c_str(), ownerIdString);
Code/Editor/TrackView/TrackViewAnimNode.cpp
+2 -2
View File
@@ -1010,13 +1010,13 @@ bool CTrackViewAnimNode::SetName(const char* pName)
}
}
string oldName = GetName();
AZStd::string oldName = GetName();
m_animNode->SetName(pName);
CTrackViewSequence* sequence = GetSequence();
AZ_Assert(sequence, "Nodes should never have a null sequence.");
sequence->OnNodeRenamed(this, oldName);
sequence->OnNodeRenamed(this, oldName.c_str());
return true;
}
Code/Editor/TrackView/TrackViewDopeSheetBase.cpp
+3 -3
View File
@@ -2808,10 +2808,10 @@ void CTrackViewDopeSheetBase::DrawKeys(CTrackViewTrack* pTrack, QPainter* painte
}
else
{
cry_strcpy(keydesc, "{");
azstrcpy(keydesc, AZ_ARRAY_SIZE(keydesc), "{");
}
cry_strcat(keydesc, pDescription);
cry_strcat(keydesc, "}");
azstrcat(keydesc, AZ_ARRAY_SIZE(keydesc), pDescription);
azstrcat(keydesc, AZ_ARRAY_SIZE(keydesc), "}");
// Draw key description text.
// Find next key.
const QRect textRect(QPoint(x + 10, rect.top()), QPoint(x1, rect.bottom()));
Code/Editor/TrackView/TrackViewFindDlg.cpp
+1 -1
View File
@@ -61,7 +61,7 @@ void CTrackViewFindDlg::FillData()
ObjName obj;
obj.m_objName = pNode->GetName();
obj.m_directorName = pNode->HasDirectorAsParent() ? pNode->HasDirectorAsParent()->GetName() : "";
string fullname = seq->GetName();
AZStd::string fullname = seq->GetName();
obj.m_seqName = fullname.c_str();
m_objs.push_back(obj);
}
Code/Editor/TrackView/TrackViewNodes.cpp
+1 -1
View File
@@ -2516,7 +2516,7 @@ int CTrackViewNodesCtrl::GetMatNameAndSubMtlIndexFromName(QString& matName, cons
if (const char* pCh = strstr(nodeName, ".["))
{
char matPath[MAX_PATH];
cry_strcpy(matPath, nodeName, (size_t)(pCh - nodeName));
azstrncpy(matPath, AZ_ARRAY_SIZE(matPath), nodeName, (size_t)(pCh - nodeName));
matName = matPath;
pCh += 2;
if ((*pCh) != 0)
Code/Editor/TrackView/TrackViewSequence.cpp
+4 -4
View File
@@ -1073,7 +1073,7 @@ std::deque<CTrackViewTrack*> CTrackViewSequence::GetMatchingTracks(CTrackViewAni
{
std::deque<CTrackViewTrack*> matchingTracks;
const string trackName = trackNode->getAttr("name");
const AZStd::string trackName = trackNode->getAttr("name");
CAnimParamType animParamType;
animParamType.LoadFromXml(trackNode);
@@ -1133,11 +1133,11 @@ void CTrackViewSequence::GetMatchedPasteLocationsRec(std::vector<TMatchedTrackLo
for (unsigned int nodeIndex = 0; nodeIndex < numChildNodes; ++nodeIndex)
{
XmlNodeRef xmlChildNode = clipboardNode->getChild(nodeIndex);
const string tagName = xmlChildNode->getTag();
const AZStd::string tagName = xmlChildNode->getTag();
if (tagName == "Node")
{
const string nodeName = xmlChildNode->getAttr("name");
const AZStd::string nodeName = xmlChildNode->getAttr("name");
int nodeType = static_cast<int>(AnimNodeType::Invalid);
xmlChildNode->getAttr("type", nodeType);
@@ -1159,7 +1159,7 @@ void CTrackViewSequence::GetMatchedPasteLocationsRec(std::vector<TMatchedTrackLo
}
else if (tagName == "Track")
{
const string trackName = xmlChildNode->getAttr("name");
const AZStd::string trackName = xmlChildNode->getAttr("name");
CAnimParamType trackParamType;
trackParamType.Serialize(xmlChildNode, true);
Code/Editor/TrackViewNewSequenceDialog.cpp
+1 -1
View File
@@ -81,7 +81,7 @@ void CTVNewSequenceDialog::OnOK()
for (int k = 0; k < GetIEditor()->GetSequenceManager()->GetCount(); ++k)
{
CTrackViewSequence* pSequence = GetIEditor()->GetSequenceManager()->GetSequenceByIndex(k);
QString fullname = QtUtil::ToQString(pSequence->GetName());
QString fullname = pSequence->GetName();
if (fullname.compare(m_sequenceName, Qt::CaseInsensitive) == 0)
{
Code/Editor/Util/AutoDirectoryRestoreFileDialog.cpp
+1 -1
View File
@@ -45,7 +45,7 @@ int CAutoDirectoryRestoreFileDialog::exec()
foreach(const QString&fileName, selectedFiles())
{
QFileInfo info(fileName);
if (!CryStringUtils::IsValidFileName(info.fileName().toStdString().c_str()))
if (!AZ::StringFunc::Path::IsValid(info.fileName().toStdString().c_str()))
{
QMessageBox::warning(this, tr("Error"), tr("Please select a valid file name (standard English alphanumeric characters only)"));
problem = true;
Code/Editor/Util/EditorUtils.cpp
-24
View File
@@ -30,30 +30,6 @@ void HeapCheck::Check([[maybe_unused]] const char* file, [[maybe_unused]] int li
_ASSERTE(_CrtCheckMemory());
#endif
/*
int heapstatus = _heapchk();
switch( heapstatus )
{
case _HEAPOK:
break;
case _HEAPEMPTY:
break;
case _HEAPBADBEGIN:
{
CString str;
str.Format( "Bad Start of Heap, at file %s line:%d",file,line );
MessageBox( nullptr,str,"Heap Check",MB_OK );
}
break;
case _HEAPBADNODE:
{
CString str;
str.Format( "Bad Node in Heap, at file %s line:%d",file,line );
MessageBox( nullptr,str,"Heap Check",MB_OK );
}
break;
}
*/
#endif
}
Code/Editor/Util/EditorUtils.h
+1
View File
@@ -18,6 +18,7 @@
#include <IXml.h>
#include "Util/FileUtil.h"
#include <Cry_Color.h>
#include <CryCommon/ISystem.h>
//! Typedef for quaternion.
//typedef CryQuat Quat;
Code/Editor/Util/FileUtil.cpp
+10 -10
View File
@@ -264,7 +264,7 @@ void CFileUtil::EditTextureFile(const char* textureFile, [[maybe_unused]] bool b
}
bool failedToLaunch = true;
QByteArray textureEditorPath = gSettings.textureEditor.toUtf8();
const QString& textureEditorPath = gSettings.textureEditor;
// Give the user a warning if they don't have a texture editor configured
if (textureEditorPath.isEmpty())
@@ -278,8 +278,7 @@ void CFileUtil::EditTextureFile(const char* textureFile, [[maybe_unused]] bool b
// Use the Win32 API calls to open the right editor; the OS knows how to do this even better than
// Qt does.
QString fullTexturePathFixedForWindows = QString(fullTexturePath.data()).replace('/', '\\');
QByteArray fullTexturePathFixedForWindowsUtf8 = fullTexturePathFixedForWindows.toUtf8();
HINSTANCE hInst = ShellExecute(nullptr, "open", textureEditorPath.data(), fullTexturePathFixedForWindowsUtf8.data(), nullptr, SW_SHOWNORMAL);
HINSTANCE hInst = ShellExecuteW(nullptr, L"open", textureEditorPath.toStdWString().c_str(), fullTexturePathFixedForWindows.toStdWString().c_str(), nullptr, SW_SHOWNORMAL);
failedToLaunch = ((DWORD_PTR)hInst <= 32);
#elif defined(AZ_PLATFORM_MAC)
failedToLaunch = QProcess::execute(QString("/usr/bin/open"), {"-a", gSettings.textureEditor, QString(fullTexturePath.data()) }) != 0;
@@ -298,7 +297,7 @@ void CFileUtil::EditTextureFile(const char* textureFile, [[maybe_unused]] bool b
//////////////////////////////////////////////////////////////////////////
bool CFileUtil::EditMayaFile(const char* filepath, const bool bExtractFromPak, const bool bUseGameFolder)
{
QString dosFilepath = QtUtil::ToQString(PathUtil::ToDosPath(filepath));
QString dosFilepath = PathUtil::ToDosPath(filepath).c_str();
if (bExtractFromPak)
{
ExtractFile(dosFilepath);
@@ -313,7 +312,7 @@ bool CFileUtil::EditMayaFile(const char* filepath, const bool bExtractFromPak, c
dosFilepath = sGameFolder + '\\' + filepath;
}
dosFilepath = PathUtil::ToDosPath(dosFilepath.toUtf8().data());
dosFilepath = PathUtil::ToDosPath(dosFilepath.toUtf8().data()).c_str();
}
const char* engineRoot;
@@ -1304,7 +1303,7 @@ IFileUtil::ECopyTreeResult CFileUtil::CopyTree(const QString& strSourceDirectory
// all with the same names and all with the same files names inside. If you would make a depth-first search
// you could end up with the files from the deepest folder in ALL your folders.
std::vector<string> ignoredPatterns;
std::vector<AZStd::string> ignoredPatterns;
StringHelpers::Split(ignoreFilesAndFolders, "|", false, ignoredPatterns);
QDirIterator::IteratorFlags flags = QDirIterator::NoIteratorFlags;
@@ -1330,7 +1329,7 @@ IFileUtil::ECopyTreeResult CFileUtil::CopyTree(const QString& strSourceDirectory
const QString fileName = QFileInfo(filePath).fileName();
bool ignored = false;
for (const string& ignoredFile : ignoredPatterns)
for (const AZStd::string& ignoredFile : ignoredPatterns)
{
if (StringHelpers::CompareIgnoreCase(fileName.toStdString().c_str(), ignoredFile.c_str()) == 0)
{
@@ -2159,13 +2158,14 @@ uint32 CFileUtil::GetAttributes(const char* filename, bool bUseSourceControl /*=
return SCC_FILE_ATTRIBUTE_READONLY | SCC_FILE_ATTRIBUTE_INPAK;
}
DWORD dwAttrib = ::GetFileAttributes(file.GetAdjustedFilename());
if (dwAttrib == INVALID_FILE_ATTRIBUTES)
const char* adjustedFile = file.GetAdjustedFilename();
if (!AZ::IO::SystemFile::Exists(adjustedFile))
{
return SCC_FILE_ATTRIBUTE_INVALID;
}
if (dwAttrib & FILE_ATTRIBUTE_READONLY)
if (!AZ::IO::SystemFile::IsWritable(adjustedFile))
{
return SCC_FILE_ATTRIBUTE_NORMAL | SCC_FILE_ATTRIBUTE_READONLY;
}
Code/Editor/Util/FileUtil.h
-2
View File
@@ -9,8 +9,6 @@
#pragma once
#include "CryThread.h"
#include "StringUtils.h"
#include "../Include/SandboxAPI.h"
#include <QString>
#include <QFileInfo>
Code/Editor/Util/IXmlHistoryManager.h
-73
View File
@@ -1,73 +0,0 @@
/*
* 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
*
*/
#ifndef CRYINCLUDE_EDITOR_UTIL_IXMLHISTORYMANAGER_H
#define CRYINCLUDE_EDITOR_UTIL_IXMLHISTORYMANAGER_H
#pragma once
// Helper class to handle Redo/Undo on set of Xml nodes
struct IXmlUndoEventHandler
{
virtual bool SaveToXml(XmlNodeRef& xmlNode) = 0;
virtual bool LoadFromXml(const XmlNodeRef& xmlNode) = 0;
virtual bool ReloadFromXml(const XmlNodeRef& xmlNode) = 0;
};
struct IXmlHistoryEventListener
{
enum EHistoryEventType
{
eHET_HistoryDeleted,
eHET_HistoryCleared,
eHET_HistorySaved,
eHET_VersionChanged,
eHET_VersionAdded,
eHET_HistoryInvalidate,
eHET_HistoryGroupChanged,
eHET_HistoryGroupAdded,
eHET_HistoryGroupRemoved,
};
virtual void OnEvent(EHistoryEventType event, void* pData = nullptr) = 0;
};
struct IXmlHistoryView
{
virtual bool LoadXml(int typeId, const XmlNodeRef& xmlNode, IXmlUndoEventHandler*& pUndoEventHandler, uint32 userindex) = 0;
virtual void UnloadXml(int typeId) = 0;
};
struct IXmlHistoryManager
{
// Undo/Redo
virtual bool Undo() = 0;
virtual bool Redo() = 0;
virtual bool Goto(int historyNum) = 0;
virtual void RecordUndo(IXmlUndoEventHandler* pEventHandler, const char* desc) = 0;
virtual void UndoEventHandlerDestroyed(IXmlUndoEventHandler* pEventHandler, uint32 typeId = 0, bool destoryForever = false) = 0;
virtual void RestoreUndoEventHandler(IXmlUndoEventHandler* pEventHandler, uint32 typeId) = 0;
virtual void RegisterEventListener(IXmlHistoryEventListener* pEventListener) = 0;
virtual void UnregisterEventListener(IXmlHistoryEventListener* pEventListener) = 0;
// History
virtual void ClearHistory(bool flagAsSaved = false) = 0;
virtual int GetVersionCount() const = 0;
virtual const string& GetVersionDesc(int number) const = 0;
virtual int GetCurrentVersionNumber() const = 0;
// Views
virtual void RegisterView(IXmlHistoryView* pView) = 0;
virtual void UnregisterView(IXmlHistoryView* pView) = 0;
};
#endif // CRYINCLUDE_EDITOR_UTIL_IXMLHISTORYMANAGER_H
Code/Editor/Util/ImageASC.cpp
+1 -2
View File
@@ -24,8 +24,7 @@ bool CImageASC::Save(const QString& fileName, const CFloatImage& image)
uint32 height = image.GetHeight();
float* pixels = image.GetData();
string fileHeader;
fileHeader.Format(
AZStd::string fileHeader = AZStd::string::format(
// Number of columns and rows in the data
"ncols %d\n"
"nrows %d\n"

Some files were not shown because too many files have changed in this diff Show More