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

Merge branch 'development' into cmake/SPEC-7484

Browse Source 
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>

# Conflicts:
#	Code/Editor/CryEditDoc.cpp
#	Code/Editor/CryEditDoc.h
#	Code/Legacy/CryCommon/CryArray.h
#	Code/Legacy/CryCommon/CryString.h
#	Code/Legacy/CryCommon/UnicodeBinding.h
#	Code/Legacy/CrySystem/LocalizedStringManager.cpp
#	Gems/LyShine/Code/Source/StringUtfUtils.h
#	Gems/PhysXDebug/Code/Source/SystemComponent.cpp
This commit is contained in:
Esteban Papp
2021-08-05 20:05:25 -07:00
parent 4358b6eb27 6b2452379f
commit e28d04aea6
389 changed files with 5267 additions and 3581 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Editor/Controls/ConsoleSCB.cpp
+19
View File
@@ -338,6 +338,8 @@ CConsoleSCB::CConsoleSCB(QWidget* parent)
connect(findPreviousAction, &QAction::triggered, this, &CConsoleSCB::findPrevious);
ui->findPrevButton->addAction(findPreviousAction);
GetIEditor()->RegisterNotifyListener(this);
connect(ui->button, &QPushButton::clicked, this, &CConsoleSCB::showVariableEditor);
connect(ui->findButton, &QPushButton::clicked, this, &CConsoleSCB::toggleConsoleSearch);
connect(ui->textEdit, &ConsoleTextEdit::searchBarRequested, this, [this]
@@ -376,6 +378,8 @@ CConsoleSCB::~CConsoleSCB()
{
AzToolsFramework::EditorPreferencesNotificationBus::Handler::BusDisconnect();
GetIEditor()->UnregisterNotifyListener(this);
s_consoleSCB = nullptr;
CLogFile::AttachEditBox(nullptr);
}
@@ -1352,4 +1356,19 @@ CConsoleSCB* CConsoleSCB::GetCreatedInstance()
return s_consoleSCB;
}
void CConsoleSCB::OnEditorNotifyEvent(EEditorNotifyEvent event)
{
switch (event)
{
case eNotify_OnBeginGameMode:
if (gSettings.clearConsoleOnGameModeStart)
{
ui->textEdit->clear();
}
break;
default:
break;
}
}
#include <Controls/moc_ConsoleSCB.cpp>
Code/Editor/Controls/ConsoleSCB.h
+3
View File
@@ -159,6 +159,7 @@ private:
class CConsoleSCB
: public QWidget
, private AzToolsFramework::EditorPreferencesNotificationBus::Handler
, public IEditorNotifyListener
{
Q_OBJECT
public:
@@ -187,6 +188,8 @@ private Q_SLOTS:
void findNext();
private:
void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
QScopedPointer<Ui::Console> ui;
int m_richEditTextLength;
Code/Editor/Controls/ReflectedPropertyControl/ReflectedPropertyItem.h
+1 -1
View File
@@ -122,7 +122,7 @@ protected:
public:
//! Get number of child nodes.
int GetChildCount() const { return m_childs.size(); };
int GetChildCount() const { return static_cast<int>(m_childs.size()); };
//! Get Child by id.
ReflectedPropertyItem* GetChild(int index) const { return m_childs[index]; }
PropertyType GetType() const { return m_type; }
Code/Editor/Core/LevelEditorMenuHandler.cpp
+4 -4
View File
@@ -544,12 +544,12 @@ void LevelEditorMenuHandler::PopulateEditMenu(ActionManager::MenuWrapper& editMe
auto snapMenu = modifyMenu.AddMenu(tr("Snap"));
snapMenu.AddAction(ID_SNAPANGLE);
snapMenu.AddAction(AzToolsFramework::SnapAngle);
auto transformModeMenu = modifyMenu.AddMenu(tr("Transform Mode"));
transformModeMenu.AddAction(ID_EDITMODE_MOVE);
transformModeMenu.AddAction(ID_EDITMODE_ROTATE);
transformModeMenu.AddAction(ID_EDITMODE_SCALE);
transformModeMenu.AddAction(AzToolsFramework::EditModeMove);
transformModeMenu.AddAction(AzToolsFramework::EditModeRotate);
transformModeMenu.AddAction(AzToolsFramework::EditModeScale);
editMenu.AddSeparator();
Code/Editor/CryEdit.cpp
+8 -73
View File
@@ -375,9 +375,6 @@ void CCryEditApp::RegisterActionHandlers()
});
ON_COMMAND(ID_MOVE_OBJECT, OnMoveObject)
ON_COMMAND(ID_RENAME_OBJ, OnRenameObj)
ON_COMMAND(ID_EDITMODE_MOVE, OnEditmodeMove)
ON_COMMAND(ID_EDITMODE_ROTATE, OnEditmodeRotate)
ON_COMMAND(ID_EDITMODE_SCALE, OnEditmodeScale)
ON_COMMAND(ID_UNDO, OnUndo)
ON_COMMAND(ID_TOOLBAR_WIDGET_REDO, OnUndo) // Can't use the same ID, because for the menu we can't have a QWidgetAction, while for the toolbar we want one
ON_COMMAND(ID_IMPORT_ASSET, OnOpenAssetImporter)
@@ -2574,75 +2571,6 @@ void CCryEditApp::OnRenameObj()
{
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnEditmodeMove()
{
using namespace AzToolsFramework;
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(),
&EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Translation);
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnEditmodeRotate()
{
using namespace AzToolsFramework;
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(),
&EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Rotation);
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnEditmodeScale()
{
using namespace AzToolsFramework;
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(),
&EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Scale);
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnUpdateEditmodeMove(QAction* action)
{
Q_ASSERT(action->isCheckable());
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Translation);
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnUpdateEditmodeRotate(QAction* action)
{
Q_ASSERT(action->isCheckable());
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Rotation);
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnUpdateEditmodeScale(QAction* action)
{
Q_ASSERT(action->isCheckable());
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Scale);
}
void CCryEditApp::OnViewSwitchToGame()
{
if (IsInPreviewMode())
@@ -2896,7 +2824,14 @@ void CCryEditApp::OpenProjectManager(const AZStd::string& screen)
{
// provide the current project path for in case we want to update the project
AZ::IO::FixedMaxPathString projectPath = AZ::Utils::GetProjectPath();
const AZStd::string commandLineOptions = AZStd::string::format(" --screen %s --project-path %s", screen.c_str(), projectPath.c_str());
#if !AZ_TRAIT_OS_PLATFORM_APPLE && !AZ_TRAIT_OS_USE_WINDOWS_FILE_PATHS
const char* argumentQuoteString = R"(")";
#else
const char* argumentQuoteString = R"(\")";
#endif
const AZStd::string commandLineOptions = AZStd::string::format(R"( --screen %s --project-path %s%s%s)",
screen.c_str(),
argumentQuoteString, projectPath.c_str(), argumentQuoteString);
bool launchSuccess = AzFramework::ProjectManager::LaunchProjectManager(commandLineOptions);
if (!launchSuccess)
{
Code/Editor/CryEdit.h
-6
View File
@@ -208,12 +208,6 @@ public:
void DeleteSelectedEntities(bool includeDescendants);
void OnMoveObject();
void OnRenameObj();
void OnEditmodeMove();
void OnEditmodeRotate();
void OnEditmodeScale();
void OnUpdateEditmodeMove(QAction* action);
void OnUpdateEditmodeRotate(QAction* action);
void OnUpdateEditmodeScale(QAction* action);
void OnUndo();
void OnOpenAssetImporter();
void OnUpdateSelected(QAction* action);
Code/Editor/CryEditDoc.cpp
+63 -84
View File
@@ -108,21 +108,12 @@ namespace Internal
// CCryEditDoc construction/destruction
CCryEditDoc::CCryEditDoc()
: doc_validate_surface_types(0)
: doc_validate_surface_types(nullptr)
, m_modifiedModuleFlags(eModifiedNothing)
// It assumes loaded levels have already been exported. Can be a big fat lie, though.
// The right way would require us to save to the level folder the export status of the
// level.
, m_boLevelExported(true)
, m_modified(false)
, m_envProbeHeight(200.0f)
, m_envProbeSliceRelativePath("EngineAssets/Slices/DefaultLevelSetup.slice")
{
////////////////////////////////////////////////////////////////////////
// Set member variables to initial values
////////////////////////////////////////////////////////////////////////
m_bLoadFailed = false;
m_waterColor = QColor(0, 0, 255);
m_fogTemplate = GetIEditor()->FindTemplate("Fog");
m_environmentTemplate = GetIEditor()->FindTemplate("Environment");
@@ -136,7 +127,6 @@ CCryEditDoc::CCryEditDoc()
m_environmentTemplate = XmlHelpers::CreateXmlNode("Environment");
}
m_bDocumentReady = false;
GetIEditor()->SetDocument(this);
CLogFile::WriteLine("Document created");
RegisterConsoleVariables();
@@ -195,7 +185,7 @@ CCryEditDoc::DocumentEditingMode CCryEditDoc::GetEditMode() const
QString CCryEditDoc::GetActivePathName() const
{
return DocumentEditingMode() == CCryEditDoc::DocumentEditingMode::SliceEdit ? GetSlicePathName() : GetLevelPathName();
return GetEditMode() == CCryEditDoc::DocumentEditingMode::SliceEdit ? GetSlicePathName() : GetLevelPathName();
}
QString CCryEditDoc::GetTitle() const
@@ -260,9 +250,9 @@ void CCryEditDoc::DeleteContents()
GetIEditor()->FlushUndo();
// Notify listeners.
for (std::list<IDocListener*>::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
for (IDocListener* listener : m_listeners)
{
(*it)->OnCloseDocument();
listener->OnCloseDocument();
}
GetIEditor()->ResetViews();
@@ -458,7 +448,7 @@ void CCryEditDoc::Load(TDocMultiArchive& arrXmlAr, const QString& szFilename)
//////////////////////////////////////////////////////////////////////////
// Load water color.
//////////////////////////////////////////////////////////////////////////
(*arrXmlAr[DMAS_GENERAL]).root->getAttr("WaterColor", m_waterColor);
(*arrXmlAr[DMAS_GENERAL]).root->getAttr("WaterColor", m_waterColor);
//////////////////////////////////////////////////////////////////////////
// Load View Settings
@@ -507,9 +497,9 @@ void CCryEditDoc::Load(TDocMultiArchive& arrXmlAr, const QString& szFilename)
CAutoLogTime logtime("Post Load");
// Notify listeners.
for (std::list<IDocListener*>::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
for (IDocListener* listener : m_listeners)
{
(*it)->OnLoadDocument();
listener->OnLoadDocument();
}
}
@@ -708,7 +698,8 @@ bool CCryEditDoc::SaveModified()
return true;
}
auto button = QMessageBox::question(AzToolsFramework::GetActiveWindow(), QString(), tr("Save changes to %1?").arg(GetTitle()), QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
auto button = QMessageBox::question(AzToolsFramework::GetActiveWindow(), QString(), tr("Save changes to %1?").arg(GetTitle()),
QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
switch (button)
{
case QMessageBox::Cancel:
@@ -933,8 +924,7 @@ bool CCryEditDoc::OnSaveDocument(const QString& lpszPathName)
}
TSaveDocContext context;
if (shouldSaveLevel &&
BeforeSaveDocument(lpszPathName, context))
if (shouldSaveLevel && BeforeSaveDocument(lpszPathName, context))
{
DoSaveDocument(lpszPathName, context);
saveSuccess = AfterSaveDocument(lpszPathName, context);
@@ -972,7 +962,7 @@ bool CCryEditDoc::BeforeSaveDocument(const QString& lpszPathName, TSaveDocContex
return TRUE;
}
bool CCryEditDoc::HasLayerNameConflicts()
bool CCryEditDoc::HasLayerNameConflicts() const
{
AZStd::vector<AZ::Entity*> editorEntities;
AzToolsFramework::EditorEntityContextRequestBus::Broadcast(
@@ -1004,43 +994,42 @@ bool CCryEditDoc::HasLayerNameConflicts()
bool CCryEditDoc::DoSaveDocument(const QString& filename, TSaveDocContext& context)
{
bool& bSaved = context.bSaved;
if (bSaved)
if (!bSaved)
{
// Paranoia - we shouldn't get this far into the save routine without a level loaded (empty levelPath)
// If nothing is loaded, we don't need to save anything
if (filename.isEmpty())
{
bSaved = false;
}
else
{
// Save Tag Point locations to file if auto save of tag points disabled
if (!gSettings.bAutoSaveTagPoints)
{
CCryEditApp::instance()->SaveTagLocations();
}
QString normalizedPath = Path::ToUnixPath(filename);
if (IsSliceFile(normalizedPath))
{
bSaved = SaveSlice(normalizedPath);
}
else
{
bSaved = SaveLevel(normalizedPath);
}
// Changes filename for this document.
SetPathName(normalizedPath);
}
return false;
}
// Paranoia - we shouldn't get this far into the save routine without a level loaded (empty levelPath)
// If nothing is loaded, we don't need to save anything
if (filename.isEmpty())
{
bSaved = false;
return false;
}
// Save Tag Point locations to file if auto save of tag points disabled
if (!gSettings.bAutoSaveTagPoints)
{
CCryEditApp::instance()->SaveTagLocations();
}
QString normalizedPath = Path::ToUnixPath(filename);
if (IsSliceFile(normalizedPath))
{
bSaved = SaveSlice(normalizedPath);
}
else
{
bSaved = SaveLevel(normalizedPath);
}
// Changes filename for this document.
SetPathName(normalizedPath);
return bSaved;
}
bool CCryEditDoc::AfterSaveDocument([[maybe_unused]] const QString& lpszPathName, TSaveDocContext& context, bool bShowPrompt)
{
bool& bSaved = context.bSaved;
bool bSaved = context.bSaved;
GetIEditor()->Notify(eNotify_OnEndSceneSave);
@@ -1067,8 +1056,7 @@ bool CCryEditDoc::AfterSaveDocument([[maybe_unused]] const QString& lpszPathName
static void GetUserSettingsFile(const QString& levelFolder, QString& userSettings)
{
const char* pUserName = GetISystem()->GetUserName();
QString fileName;
fileName = QStringLiteral("%1_usersettings.editor_xml").arg(pUserName);
QString fileName = QStringLiteral("%1_usersettings.editor_xml").arg(pUserName);
userSettings = Path::Make(levelFolder, fileName);
}
@@ -1182,9 +1170,9 @@ bool CCryEditDoc::SaveLevel(const QString& filename)
}
QString oldFilePath = QDir(oldLevelFolder).absoluteFilePath(sourceName);
QString newFilePath = QDir(newLevelFolder).absoluteFilePath(sourceName);
QString newFilePath = QDir(newLevelFolder).absoluteFilePath(destName);
CFileUtil::CopyFile(oldFilePath, newFilePath);
} while (findHandle = pIPak->FindNext(findHandle));
} while ((findHandle = pIPak->FindNext(findHandle)));
pIPak->FindClose(findHandle);
}
@@ -1506,7 +1494,7 @@ bool CCryEditDoc::LoadEntitiesFromLevel(const QString& levelPakFile)
{
AZStd::vector<char> fileBuffer;
fileBuffer.resize(entitiesFile.GetLength());
if (fileBuffer.size() > 0)
if (!fileBuffer.empty())
{
if (fileBuffer.size() == entitiesFile.ReadRaw(fileBuffer.begin(), fileBuffer.size()))
{
@@ -1910,7 +1898,7 @@ void CCryEditDoc::UnregisterListener(IDocListener* listener)
m_listeners.remove(listener);
}
void CCryEditDoc::LogLoadTime(int time)
void CCryEditDoc::LogLoadTime(int time) const
{
QString appFilePath = QDir::toNativeSeparators(QCoreApplication::applicationFilePath());
QString exePath = Path::GetPath(appFilePath);
@@ -1922,21 +1910,18 @@ void CCryEditDoc::LogLoadTime(int time)
SetFileAttributesW(filename.toStdWString().c_str(), FILE_ATTRIBUTE_ARCHIVE);
#endif
FILE* file = nullptr;
azfopen(&file, filename.toUtf8().data(), "at");
if (file)
QFile file(filename);
if (!file.open(QFile::Append | QFile::Text))
{
char version[50];
GetIEditor()->GetFileVersion().ToShortString(version, AZ_ARRAY_SIZE(version));
QString text;
time = time / 1000;
text = QStringLiteral("\n[%1] Level %2 loaded in %3 seconds").arg(version, level).arg(time);
fwrite(text.toUtf8().data(), text.toUtf8().length(), 1, file);
fclose(file);
return;
}
char version[50];
GetIEditor()->GetFileVersion().ToShortString(version, AZ_ARRAY_SIZE(version));
time = time / 1000;
QString text = QStringLiteral("\n[%1] Level %2 loaded in %3 seconds").arg(version, level).arg(time);
file.write(text.toUtf8());
}
void CCryEditDoc::SetDocumentReady(bool bReady)
@@ -1944,7 +1929,7 @@ void CCryEditDoc::SetDocumentReady(bool bReady)
m_bDocumentReady = bReady;
}
void CCryEditDoc::GetMemoryUsage(ICrySizer* pSizer)
void CCryEditDoc::GetMemoryUsage(ICrySizer* pSizer) const
{
{
SIZER_COMPONENT_NAME(pSizer, "UndoManager(estimate)");
@@ -2068,12 +2053,9 @@ void CCryEditDoc::InitEmptyLevel(int /*resolution*/, int /*unitSize*/, bool /*bU
{
// Notify listeners.
std::list<IDocListener*> listeners = m_listeners;
std::list<IDocListener*>::iterator it, next;
for (it = listeners.begin(); it != listeners.end(); it = next)
for (IDocListener* listener : listeners)
{
next = it;
next++;
(*it)->OnNewDocument();
listener->OnNewDocument();
}
}
@@ -2134,25 +2116,23 @@ void CCryEditDoc::OnEnvironmentPropertyChanged(IVariable* pVar)
{
return;
}
QString childValue;
if (pVar->GetDataType() == IVariable::DT_COLOR)
{
Vec3 value;
pVar->Get(value);
QString buff;
QColor gammaColor = ColorLinearToGamma(ColorF(value.x, value.y, value.z));
buff = QStringLiteral("%1,%2,%3").arg(gammaColor.red()).arg(gammaColor.green()).arg(gammaColor.blue());
childNode->setAttr("value", buff.toUtf8().data());
childValue = QStringLiteral("%1,%2,%3").arg(gammaColor.red()).arg(gammaColor.green()).arg(gammaColor.blue());
}
else
{
QString value;
pVar->Get(value);
childNode->setAttr("value", value.toUtf8().data());
pVar->Get(childValue);
}
childNode->setAttr("value", childValue.toUtf8().data());
}
QString CCryEditDoc::GetCryIndexPath(const char* levelFilePath)
QString CCryEditDoc::GetCryIndexPath(const char* levelFilePath) const
{
QString levelPath = Path::GetPath(levelFilePath);
QString levelName = Path::GetFileName(levelFilePath);
@@ -2183,8 +2163,7 @@ BOOL CCryEditDoc::LoadXmlArchiveArray(TDocMultiArchive& arrXmlAr, const QString&
}
CPakFile pakFile;
bool loadFromPakSuccess;
loadFromPakSuccess = xmlAr.LoadFromPak(levelPath, pakFile);
bool loadFromPakSuccess = xmlAr.LoadFromPak(levelPath, pakFile);
pIPak->ClosePack(absoluteLevelPath.toUtf8().data());
if (!loadFromPakSuccess)
{
Code/Editor/CryEditDoc.h
+16 -14
View File
@@ -91,7 +91,7 @@ public: // Create from serialization only
// ClassWizard generated virtual function overrides
virtual bool OnOpenDocument(const QString& lpszPathName);
const bool IsLevelLoadFailed() const { return m_bLoadFailed; }
bool IsLevelLoadFailed() const { return m_bLoadFailed; }
//! Marks this document as having errors.
void SetHasErrors() { m_hasErrors = true; }
@@ -121,7 +121,7 @@ public: // Create from serialization only
CClouds* GetClouds() { return m_pClouds; }
void SetWaterColor(const QColor& col) { m_waterColor = col; }
QColor GetWaterColor() { return m_waterColor; }
QColor GetWaterColor() const { return m_waterColor; }
XmlNodeRef& GetFogTemplate() { return m_fogTemplate; }
XmlNodeRef& GetEnvironmentTemplate() { return m_environmentTemplate; }
void OnEnvironmentPropertyChanged(IVariable* pVar);
@@ -129,7 +129,7 @@ public: // Create from serialization only
void RegisterListener(IDocListener* listener);
void UnregisterListener(IDocListener* listener);
void GetMemoryUsage(ICrySizer* pSizer);
void GetMemoryUsage(ICrySizer* pSizer) const;
static bool IsBackupOrTempLevelSubdirectory(const QString& folderName);
protected:
@@ -161,14 +161,14 @@ protected:
void SerializeFogSettings(CXmlArchive& xmlAr);
virtual void SerializeViewSettings(CXmlArchive& xmlAr);
void SerializeNameSelection(CXmlArchive& xmlAr);
void LogLoadTime(int time);
void LogLoadTime(int time) const;
struct TSaveDocContext
{
bool bSaved;
};
bool BeforeSaveDocument(const QString& lpszPathName, TSaveDocContext& context);
bool HasLayerNameConflicts();
bool HasLayerNameConflicts() const;
bool DoSaveDocument(const QString& lpszPathName, TSaveDocContext& context);
bool AfterSaveDocument(const QString& lpszPathName, TSaveDocContext& context, bool bShowPrompt = true);
@@ -180,7 +180,7 @@ protected:
void OnStartLevelResourceList();
static void OnValidateSurfaceTypesChanged(ICVar*);
QString GetCryIndexPath(const char* levelFilePath);
QString GetCryIndexPath(const char* levelFilePath) const;
//////////////////////////////////////////////////////////////////////////
// SliceEditorEntityOwnershipServiceNotificationBus::Handler
@@ -188,24 +188,26 @@ protected:
void OnSliceInstantiationFailed(const AZ::Data::AssetId& sliceAssetId, const AzFramework::SliceInstantiationTicket& /*ticket*/) override;
//////////////////////////////////////////////////////////////////////////
bool m_bLoadFailed;
QColor m_waterColor;
bool m_bLoadFailed = false;
QColor m_waterColor = QColor(0, 0, 255);
XmlNodeRef m_fogTemplate;
XmlNodeRef m_environmentTemplate;
CClouds* m_pClouds;
std::list<IDocListener*> m_listeners;
bool m_bDocumentReady;
ICVar* doc_validate_surface_types;
bool m_bDocumentReady = false;
ICVar* doc_validate_surface_types = nullptr;
int m_modifiedModuleFlags;
bool m_boLevelExported;
bool m_modified;
// On construction, it assumes loaded levels have already been exported. Can be a big fat lie, though.
// The right way would require us to save to the level folder the export status of the level.
bool m_boLevelExported = true;
bool m_modified = false;
QString m_pathName;
QString m_slicePathName;
QString m_title;
AZ::Data::AssetId m_envProbeSliceAssetId;
float m_terrainSize;
const char* m_envProbeSliceRelativePath;
const float m_envProbeHeight;
const char* m_envProbeSliceRelativePath = "EngineAssets/Slices/DefaultLevelSetup.slice";
const float m_envProbeHeight = 200.0f;
bool m_hasErrors = false; ///< This is used to warn the user that they may lose work when they go to save.
};
Code/Editor/EditorPreferencesPageGeneral.cpp
+5
View File
@@ -32,6 +32,7 @@ void CEditorPreferencesPage_General::Reflect(AZ::SerializeContext& serialize)
->Field("PreviewPanel", &GeneralSettings::m_previewPanel)
->Field("ApplyConfigSpec", &GeneralSettings::m_applyConfigSpec)
->Field("EnableSourceControl", &GeneralSettings::m_enableSourceControl)
->Field("ClearConsole", &GeneralSettings::m_clearConsoleOnGameModeStart)
->Field("ConsoleBackgroundColorTheme", &GeneralSettings::m_consoleBackgroundColorTheme)
->Field("AutoloadLastLevel", &GeneralSettings::m_autoLoadLastLevel)
->Field("ShowTimeInConsole", &GeneralSettings::m_bShowTimeInConsole)
@@ -77,6 +78,8 @@ void CEditorPreferencesPage_General::Reflect(AZ::SerializeContext& serialize)
->DataElement(AZ::Edit::UIHandlers::CheckBox, &GeneralSettings::m_previewPanel, "Show Geometry Preview Panel", "Show Geometry Preview Panel")
->DataElement(AZ::Edit::UIHandlers::CheckBox, &GeneralSettings::m_applyConfigSpec, "Hide objects by config spec", "Hide objects by config spec")
->DataElement(AZ::Edit::UIHandlers::CheckBox, &GeneralSettings::m_enableSourceControl, "Enable Source Control", "Enable Source Control")
->DataElement(
AZ::Edit::UIHandlers::CheckBox, &GeneralSettings::m_clearConsoleOnGameModeStart, "Clear Console at game startup", "Clear Console when game mode starts")
->DataElement(AZ::Edit::UIHandlers::ComboBox, &GeneralSettings::m_consoleBackgroundColorTheme, "Console Background", "Console Background")
->EnumAttribute(AzToolsFramework::ConsoleColorTheme::Light, "Light")
->EnumAttribute(AzToolsFramework::ConsoleColorTheme::Dark, "Dark")
@@ -142,6 +145,7 @@ void CEditorPreferencesPage_General::OnApply()
gSettings.bPreviewGeometryWindow = m_generalSettings.m_previewPanel;
gSettings.bApplyConfigSpecInEditor = m_generalSettings.m_applyConfigSpec;
gSettings.enableSourceControl = m_generalSettings.m_enableSourceControl;
gSettings.clearConsoleOnGameModeStart = m_generalSettings.m_clearConsoleOnGameModeStart;
gSettings.consoleBackgroundColorTheme = m_generalSettings.m_consoleBackgroundColorTheme;
gSettings.bShowTimeInConsole = m_generalSettings.m_bShowTimeInConsole;
gSettings.bShowDashboardAtStartup = m_messaging.m_showDashboard;
@@ -176,6 +180,7 @@ void CEditorPreferencesPage_General::InitializeSettings()
m_generalSettings.m_previewPanel = gSettings.bPreviewGeometryWindow;
m_generalSettings.m_applyConfigSpec = gSettings.bApplyConfigSpecInEditor;
m_generalSettings.m_enableSourceControl = gSettings.enableSourceControl;
m_generalSettings.m_clearConsoleOnGameModeStart = gSettings.clearConsoleOnGameModeStart;
m_generalSettings.m_consoleBackgroundColorTheme = gSettings.consoleBackgroundColorTheme;
m_generalSettings.m_bShowTimeInConsole = gSettings.bShowTimeInConsole;
m_generalSettings.m_autoLoadLastLevel = gSettings.bAutoloadLastLevelAtStartup;
Code/Editor/EditorPreferencesPageGeneral.h
+1
View File
@@ -46,6 +46,7 @@ private:
bool m_previewPanel;
bool m_applyConfigSpec;
bool m_enableSourceControl;
bool m_clearConsoleOnGameModeStart;
AzToolsFramework::ConsoleColorTheme m_consoleBackgroundColorTheme;
bool m_autoLoadLastLevel;
bool m_bShowTimeInConsole;
Code/Editor/EditorViewportWidget.cpp
+13 -2
View File
@@ -472,6 +472,12 @@ void EditorViewportWidget::Update()
m_Camera.SetZRange(cameraState.m_nearClip, cameraState.m_farClip);
}
// Ensure the FOV matches our internally stored setting if we're using the Editor camera
if (!m_viewEntityId.IsValid() && !GetIEditor()->IsInGameMode())
{
SetFOV(GetFOV());
}
// Reset the camera update flag now that we're finished updating our viewport context
m_updateCameraPositionNextTick = false;
@@ -1234,6 +1240,13 @@ AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateMod
AzFramework::ViewportId viewportId)
{
auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
controller->SetCameraPriorityBuilderCallback(
[](AtomToolsFramework::CameraControllerPriorityFn& cameraControllerPriorityFn)
{
cameraControllerPriorityFn = AtomToolsFramework::DefaultCameraControllerPriority;
});
controller->SetCameraPropsBuilderCallback(
[](AzFramework::CameraProps& cameraProps)
{
@@ -2624,8 +2637,6 @@ void EditorViewportWidget::DestroyRenderContext()
//////////////////////////////////////////////////////////////////////////
void EditorViewportWidget::SetDefaultCamera()
{
// Ensure the FOV matches our internally stored setting
SetFOV(GetFOV());
if (IsDefaultCamera())
{
return;
Code/Editor/EditorViewportWidget.h
+3 -3
View File
@@ -258,19 +258,19 @@ public:
m_relCameraRotX = 0;
m_relCameraRotZ = 0;
uint32 numSample6 = m_arrAnimatedCharacterPath.size();
uint32 numSample6 = static_cast<uint32>(m_arrAnimatedCharacterPath.size());
for (uint32 i = 0; i < numSample6; i++)
{
m_arrAnimatedCharacterPath[i] = Vec3(ZERO);
}
numSample6 = m_arrSmoothEntityPath.size();
numSample6 = static_cast<uint32>(m_arrSmoothEntityPath.size());
for (uint32 i = 0; i < numSample6; i++)
{
m_arrSmoothEntityPath[i] = Vec3(ZERO);
}
uint32 numSample7 = m_arrRunStrafeSmoothing.size();
uint32 numSample7 = static_cast<uint32>(m_arrRunStrafeSmoothing.size());
for (uint32 i = 0; i < numSample7; i++)
{
m_arrRunStrafeSmoothing[i] = 0;
Code/Editor/ErrorReport.h
+1 -1
View File
@@ -105,7 +105,7 @@ public:
bool IsEmpty() const;
//! Get number of contained error records.
int GetErrorCount() const { return m_errors.size(); };
int GetErrorCount() const { return static_cast<int>(m_errors.size()); };
//! Get access to indexed error record.
CErrorRecord& GetError(int i);
//! Clear all error records.
Code/Editor/GameEngine.cpp
+1 -1
View File
@@ -566,7 +566,7 @@ void CGameEngine::SwitchToInGame()
streamer->QueueRequest(flush);
wait.acquire();
}
GetIEditor()->Notify(eNotify_OnBeginGameMode);
m_pISystem->GetIMovieSystem()->EnablePhysicsEvents(true);
Code/Editor/MainWindow.cpp
+61 -8
View File
@@ -46,6 +46,7 @@ AZ_POP_DISABLE_WARNING
#include <AzToolsFramework/API/EditorAnimationSystemRequestBus.h>
#include <AzToolsFramework/SourceControl/QtSourceControlNotificationHandler.h>
#include <AzToolsFramework/PythonTerminal/ScriptTermDialog.h>
#include <AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h>
// AzQtComponents
#include <AzQtComponents/Buses/ShortcutDispatch.h>
@@ -731,32 +732,84 @@ void MainWindow::InitActions()
.SetStatusTip(tr("Restore saved state (Fetch)"));
// Modify actions
am->AddAction(ID_EDITMODE_MOVE, tr("Move"))
am->AddAction(AzToolsFramework::EditModeMove, tr("Move"))
.SetIcon(Style::icon("Move"))
.SetApplyHoverEffect()
.SetShortcut(tr("1"))
.SetToolTip(tr("Move (1)"))
.SetCheckable(true)
.SetStatusTip(tr("Select and move selected object(s)"))
.RegisterUpdateCallback(cryEdit, &CCryEditApp::OnUpdateEditmodeMove);
am->AddAction(ID_EDITMODE_ROTATE, tr("Rotate"))
.RegisterUpdateCallback([](QAction* action)
{
Q_ASSERT(action->isCheckable());
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Translation);
})
.Connect(
&QAction::triggered,
[]()
{
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(), &EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Translation);
});
am->AddAction(AzToolsFramework::EditModeRotate, tr("Rotate"))
.SetIcon(Style::icon("Translate"))
.SetApplyHoverEffect()
.SetShortcut(tr("2"))
.SetToolTip(tr("Rotate (2)"))
.SetCheckable(true)
.SetStatusTip(tr("Select and rotate selected object(s)"))
.RegisterUpdateCallback(cryEdit, &CCryEditApp::OnUpdateEditmodeRotate);
am->AddAction(ID_EDITMODE_SCALE, tr("Scale"))
.RegisterUpdateCallback([](QAction* action)
{
Q_ASSERT(action->isCheckable());
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Rotation);
})
.Connect(
&QAction::triggered,
[]()
{
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(), &EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Rotation);
});
am->AddAction(AzToolsFramework::EditModeScale, tr("Scale"))
.SetIcon(Style::icon("Scale"))
.SetApplyHoverEffect()
.SetShortcut(tr("3"))
.SetToolTip(tr("Scale (3)"))
.SetCheckable(true)
.SetStatusTip(tr("Select and scale selected object(s)"))
.RegisterUpdateCallback(cryEdit, &CCryEditApp::OnUpdateEditmodeScale);
.RegisterUpdateCallback([](QAction* action)
{
Q_ASSERT(action->isCheckable());
am->AddAction(ID_SNAP_TO_GRID, tr("Snap to grid"))
AzToolsFramework::EditorTransformComponentSelectionRequests::Mode mode;
AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
mode, AzToolsFramework::GetEntityContextId(),
&AzToolsFramework::EditorTransformComponentSelectionRequests::GetTransformMode);
action->setChecked(mode == AzToolsFramework::EditorTransformComponentSelectionRequests::Mode::Scale);
})
.Connect( &QAction::triggered,[]()
{
EditorTransformComponentSelectionRequestBus::Event(
GetEntityContextId(), &EditorTransformComponentSelectionRequests::SetTransformMode,
EditorTransformComponentSelectionRequests::Mode::Scale);
});
am->AddAction(AzToolsFramework::SnapToGrid, tr("Snap to grid"))
.SetIcon(Style::icon("Grid"))
.SetApplyHoverEffect()
.SetShortcut(tr("G"))
@@ -769,7 +822,7 @@ void MainWindow::InitActions()
})
.Connect(&QAction::triggered, []() { SandboxEditor::SetGridSnapping(!SandboxEditor::GridSnappingEnabled()); });
am->AddAction(ID_SNAPANGLE, tr("Snap angle"))
am->AddAction(AzToolsFramework::SnapAngle, tr("Snap angle"))
.SetIcon(Style::icon("Angle"))
.SetApplyHoverEffect()
.SetStatusTip(tr("Snap angle"))
Code/Editor/MainWindow.h
+10 -4
View File
@@ -59,11 +59,17 @@ namespace AzQtComponents
namespace AzToolsFramework
{
class Ticker;
}
namespace AzToolsFramework
{
class QtSourceControlNotificationHandler;
//! @name Reverse URLs.
//! Used to identify common actions and override them when necessary.
//@{
constexpr inline AZ::Crc32 EditModeMove = AZ_CRC_CE("com.o3de.action.editor.editmode.move");
constexpr inline AZ::Crc32 EditModeRotate = AZ_CRC_CE("com.o3de.action.editor.editmode.rotate");
constexpr inline AZ::Crc32 EditModeScale = AZ_CRC_CE("com.o3de.action.editor.editmode.scale");
constexpr inline AZ::Crc32 SnapToGrid = AZ_CRC_CE("com.o3de.action.editor.snaptogrid");
constexpr inline AZ::Crc32 SnapAngle = AZ_CRC_CE("com.o3de.action.editor.snapangle");
//@}
}
#define MAINFRM_LAYOUT_NORMAL "NormalLayout"
Code/Editor/Objects/DisplayContextShared.inl
+5 -5
View File
@@ -74,12 +74,12 @@ void DisplayContext::DrawTri(const Vec3& p1, const Vec3& p2, const Vec3& p3)
void DisplayContext::DrawTriangles(const AZStd::vector<Vec3>& vertices, const ColorB& color)
{
pRenderAuxGeom->DrawTriangles(vertices.begin(), vertices.size(), color);
pRenderAuxGeom->DrawTriangles(vertices.begin(), static_cast<uint32>(vertices.size()), color);
}
void DisplayContext::DrawTrianglesIndexed(const AZStd::vector<Vec3>& vertices, const AZStd::vector<vtx_idx>& indices, const ColorB& color)
{
pRenderAuxGeom->DrawTriangles(vertices.begin(), vertices.size(), indices.begin(), indices.size(), color);
pRenderAuxGeom->DrawTriangles(vertices.begin(), static_cast<uint32>(vertices.size()), indices.begin(), static_cast<uint32_t>(indices.size()), color);
}
//////////////////////////////////////////////////////////////////////////
@@ -862,7 +862,7 @@ void DisplayContext::DrawLine(const Vec3& p1, const Vec3& p2, const QColor& rgb1
//////////////////////////////////////////////////////////////////////////
void DisplayContext::DrawLines(const AZStd::vector<Vec3>& points, const ColorF& color)
{
pRenderAuxGeom->DrawLines(points.begin(), points.size(), color, m_thickness);
pRenderAuxGeom->DrawLines(points.begin(), static_cast<uint32>(points.size()), color, m_thickness);
}
//////////////////////////////////////////////////////////////////////////
@@ -1287,8 +1287,8 @@ void DisplayContext::Flush2D()
uvs[3] = 0;
uvt[3] = 0;
int nLabels = m_textureLabels.size();
for (int i = 0; i < nLabels; i++)
const size_t nLabels = m_textureLabels.size();
for (size_t i = 0; i < nLabels; i++)
{
STextureLabel& t = m_textureLabels[i];
float w2 = t.w * 0.5f;
Code/Editor/Objects/EntityObject.h
+2 -2
View File
@@ -163,7 +163,7 @@ public:
//////////////////////////////////////////////////////////////////////////
//! Return number of event targets of Script.
int GetEventTargetCount() const { return m_eventTargets.size(); };
int GetEventTargetCount() const { return static_cast<int>(m_eventTargets.size()); };
CEntityEventTarget& GetEventTarget(int index) { return m_eventTargets[index]; };
//! Add new event target, returns index of created event target.
//! Event targets are Always entities.
@@ -176,7 +176,7 @@ public:
// Entity Links.
//////////////////////////////////////////////////////////////////////////
//! Return number of event targets of Script.
int GetEntityLinkCount() const { return m_links.size(); };
int GetEntityLinkCount() const { return static_cast<int>(m_links.size()); };
CEntityLink& GetEntityLink(int index) { return m_links[index]; };
virtual int AddEntityLink(const QString& name, GUID targetEntityId);
virtual bool EntityLinkExists(const QString& name, GUID targetEntityId);
Code/Editor/Objects/ObjectLoader.h
+1 -1
View File
@@ -70,7 +70,7 @@ AZ_POP_DISABLE_DLL_EXPORT_BASECLASS_WARNING
CBaseObject* LoadObject(const XmlNodeRef& objNode, CBaseObject* pPrevObject = NULL);
//////////////////////////////////////////////////////////////////////////
int GetLoadedObjectsCount() { return m_loadedObjects.size(); }
int GetLoadedObjectsCount() { return static_cast<int>(m_loadedObjects.size()); }
CBaseObject* GetLoadedObject(int nIndex) const { return m_loadedObjects[nIndex].pObject; }
//! If true new loaded objects will be assigned new GUIDs.
Code/Editor/Objects/ObjectManager.h
+1 -1
View File
@@ -58,7 +58,7 @@ public:
class CBaseObjectsCache
{
public:
int GetObjectCount() const { return m_objects.size(); }
int GetObjectCount() const { return static_cast<int>(m_objects.size()); }
CBaseObject* GetObject(int nIndex) const { return m_objects[nIndex]; }
void AddObject(CBaseObject* object);
Code/Editor/Objects/SelectionGroup.h
+1 -1
View File
@@ -71,7 +71,7 @@ public:
//! And save resulting objects to saveTo selection.
void FilterParents();
//! Get number of child filtered objects.
int GetFilteredCount() const { return m_filtered.size(); }
int GetFilteredCount() const { return static_cast<int>(m_filtered.size()); }
CBaseObject* GetFilteredObject(int i) const { return m_filtered[i]; }
//////////////////////////////////////////////////////////////////////////
Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
+1 -1
View File
@@ -803,7 +803,7 @@ void SandboxIntegrationManager::SetupLayerContextMenu(QMenu* menu)
menu->addSeparator();
const int selectedLayerCount = layersInSelection.size();
const int selectedLayerCount = static_cast<int>(layersInSelection.size());
QString saveTitle = QObject::tr("Save layer");
if(selectedLayerCount > 1)
{
Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp
+1 -1
View File
@@ -259,7 +259,7 @@ QVariant OutlinerListModel::dataForName(const QModelIndex& index, int role) cons
if (highlightTextIndex >= 0)
{
const QString BACKGROUND_COLOR{ "#707070" };
label.insert(highlightTextIndex + m_filterString.length(), "</span>");
label.insert(static_cast<int>(highlightTextIndex + m_filterString.length()), "</span>");
label.insert(highlightTextIndex, "<span style=\"background-color: " + BACKGROUND_COLOR + "\">");
}
} while(highlightTextIndex > 0);
Code/Editor/Plugins/PerforcePlugin/PasswordDlg.cpp
+1 -1
View File
@@ -53,7 +53,7 @@ namespace PerforceConnection
setEnabled(false);
int numSettingsToGet = m_retrievedSettings.size();
int numSettingsToGet = static_cast<int>(m_retrievedSettings.size());
auto applySettingResultFunction = [this, &numSettingsToGet](AZStd::string setting, const SourceControlSettingInfo& info) -> void
{
Code/Editor/RenderHelpers/AxisHelperShared.inl
+1 -1
View File
@@ -546,7 +546,7 @@ bool CAxisHelper::HitTestForRotationCircle(const Matrix34& worldTM, IDisplayView
Vec3 vShortestHitPos;
float shortestDist = 3e11f;
for (int i = 0, iCount(vList.size()); i < iCount; ++i)
for (int i = 0, iCount(static_cast<int>(vList.size())); i < iCount; ++i)
{
const Vec3& v0 = vList[i];
const Vec3& v1 = vList[(i + 1) % iCount];
Code/Editor/RenderViewport.cpp
+3 -3
View File
@@ -2342,7 +2342,7 @@ bool CRenderViewport::AddCameraMenuItems(QMenu* menu)
AZ::EBusAggregateResults<AZ::EntityId> getCameraResults;
Camera::CameraBus::BroadcastResult(getCameraResults, &Camera::CameraRequests::GetCameras);
const int numCameras = getCameraResults.values.size();
const int numCameras = static_cast<int>(getCameraResults.values.size());
// only enable if we're editing a sequence in Track View and have cameras in the level
bool enableSequenceCameraMenu = (GetIEditor()->GetAnimation()->GetSequence() && numCameras);
@@ -2354,7 +2354,7 @@ bool CRenderViewport::AddCameraMenuItems(QMenu* menu)
connect(action, &QAction::triggered, this, &CRenderViewport::SetSequenceCamera);
QVector<QAction*> additionalCameras;
additionalCameras.reserve(getCameraResults.values.size());
additionalCameras.reserve(static_cast<int>(getCameraResults.values.size()));
for (const AZ::EntityId& entityId : getCameraResults.values)
{
@@ -2930,7 +2930,7 @@ void CRenderViewport::RenderSelectedRegion()
// Draw volume
dc.DepthWriteOff();
dc.CullOff();
dc.pRenderAuxGeom->DrawTriangles(&verts[0], verts.size(), &inds[0], numInds, &colors[0]);
dc.pRenderAuxGeom->DrawTriangles(&verts[0], static_cast<uint32>(verts.size()), &inds[0], numInds, &colors[0]);
dc.CullOn();
dc.DepthWriteOn();
}
Code/Editor/RenderViewport.h
+3 -3
View File
@@ -275,19 +275,19 @@ public:
m_relCameraRotX = 0;
m_relCameraRotZ = 0;
uint32 numSample6 = m_arrAnimatedCharacterPath.size();
uint32 numSample6 = static_cast<uint32>(m_arrAnimatedCharacterPath.size());
for (uint32 i = 0; i < numSample6; i++)
{
m_arrAnimatedCharacterPath[i] = Vec3(ZERO);
}
numSample6 = m_arrSmoothEntityPath.size();
numSample6 = static_cast<uint32>(m_arrSmoothEntityPath.size());
for (uint32 i = 0; i < numSample6; i++)
{
m_arrSmoothEntityPath[i] = Vec3(ZERO);
}
uint32 numSample7 = m_arrRunStrafeSmoothing.size();
uint32 numSample7 = static_cast<uint32>(m_arrRunStrafeSmoothing.size());
for (uint32 i = 0; i < numSample7; i++)
{
m_arrRunStrafeSmoothing[i] = 0;
Code/Editor/Resource.h
-5
View File
@@ -82,7 +82,6 @@
#define ID_TOOLS_CUSTOMIZEKEYBOARD 32914
#define ID_EXPORT_INDOORS 32915
#define ID_VIEW_CYCLE2DVIEWPORT 32916
#define ID_SNAPANGLE 32917
#define ID_PHYSICS_GETPHYSICSSTATE 32937
#define ID_PHYSICS_RESETPHYSICSSTATE 32938
#define ID_GAME_SYNCPLAYER 32941
@@ -108,9 +107,6 @@
#define ID_MOVE_OBJECT 33481
#define ID_RENAME_OBJ 33483
#define ID_FETCH 33496
#define ID_EDITMODE_ROTATE 33506
#define ID_EDITMODE_SCALE 33507
#define ID_EDITMODE_MOVE 33508
#define ID_SELECTION_DELETE 33512
#define ID_EDIT_ESCAPE 33513
#define ID_UNDO 33524
@@ -137,7 +133,6 @@
#define ID_ADDNODE 33570
#define ID_ADDSCENETRACK 33573
#define ID_FIND 33574
#define ID_SNAP_TO_GRID 33575
#define ID_TAG_LOC1 33576
#define ID_TAG_LOC2 33577
#define ID_TAG_LOC3 33578
Code/Editor/Settings.cpp
+7 -2
View File
@@ -189,6 +189,7 @@ SEditorSettings::SEditorSettings()
consoleBackgroundColorTheme = AzToolsFramework::ConsoleColorTheme::Dark;
bShowTimeInConsole = false;
clearConsoleOnGameModeStart = false;
enableSceneInspector = false;
@@ -527,6 +528,8 @@ void SEditorSettings::Save()
SaveValue("Settings", "ConsoleBackgroundColorThemeV2", (int)consoleBackgroundColorTheme);
SaveValue("Settings", "ClearConsoleOnGameModeStart", clearConsoleOnGameModeStart);
SaveValue("Settings", "ShowTimeInConsole", bShowTimeInConsole);
SaveValue("Settings", "EnableSceneInspector", enableSceneInspector);
@@ -729,6 +732,8 @@ void SEditorSettings::Load()
consoleBackgroundColorTheme = AzToolsFramework::ConsoleColorTheme::Dark;
}
LoadValue("Settings", "ClearConsoleOnGameModeStart", clearConsoleOnGameModeStart);
LoadValue("Settings", "ShowTimeInConsole", bShowTimeInConsole);
LoadValue("Settings", "EnableSceneInspector", enableSceneInspector);
@@ -1067,7 +1072,7 @@ void SEditorSettings::ConvertPath(const AZStd::string_view sourcePath, AZStd::st
AzToolsFramework::EditorSettingsAPIRequests::SettingOutcome SEditorSettings::GetValue(const AZStd::string_view path)
{
if (path.find("|") < 0)
if (path.find("|") == AZStd::string_view::npos)
{
return { AZStd::string("Invalid Path - could not find separator \"|\"") };
}
@@ -1085,7 +1090,7 @@ AzToolsFramework::EditorSettingsAPIRequests::SettingOutcome SEditorSettings::Get
AzToolsFramework::EditorSettingsAPIRequests::SettingOutcome SEditorSettings::SetValue(const AZStd::string_view path, const AZStd::any& value)
{
if (path.find("|") < 0)
if (path.find("|") == AZStd::string_view::npos)
{
return { AZStd::string("Invalid Path - could not find separator \"|\"") };
}
Code/Editor/Settings.h
+1
View File
@@ -380,6 +380,7 @@ AZ_POP_DISABLE_DLL_EXPORT_BASECLASS_WARNING
//! Source Control Enabling.
bool enableSourceControl;
bool clearConsoleOnGameModeStart;
//! Text editor.
QString textEditorForScript;
Code/Editor/TrackView/TrackViewAnimNode.h
+1 -1
View File
@@ -27,7 +27,7 @@ class QWidget;
class CTrackViewAnimNodeBundle
{
public:
unsigned int GetCount() const { return m_animNodes.size(); }
unsigned int GetCount() const { return static_cast<unsigned int>(m_animNodes.size()); }
CTrackViewAnimNode* GetNode(const unsigned int index) { return m_animNodes[index]; }
const CTrackViewAnimNode* GetNode(const unsigned int index) const { return m_animNodes[index]; }
Code/Editor/TrackView/TrackViewNode.h
+2 -2
View File
@@ -123,7 +123,7 @@ public:
virtual bool AreAllKeysOfSameType() const override { return m_bAllOfSameType; }
virtual unsigned int GetKeyCount() const override { return m_keys.size(); }
virtual unsigned int GetKeyCount() const override { return static_cast<unsigned int>(m_keys.size()); }
virtual CTrackViewKeyHandle GetKey(unsigned int index) override { return m_keys[index]; }
virtual void SelectKeys(const bool bSelected) override;
@@ -174,7 +174,7 @@ public:
CTrackViewNode* GetParentNode() const { return m_pParentNode; }
// Children
unsigned int GetChildCount() const { return m_childNodes.size(); }
unsigned int GetChildCount() const { return static_cast<unsigned int>(m_childNodes.size()); }
CTrackViewNode* GetChild(unsigned int index) const { return m_childNodes[index].get(); }
// Snap time value to prev/next key in sequence
Code/Editor/TrackView/TrackViewSequenceManager.h
+1 -1
View File
@@ -29,7 +29,7 @@ public:
virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
unsigned int GetCount() const { return m_sequences.size(); }
unsigned int GetCount() const { return static_cast<int>(m_sequences.size()); }
void CreateSequence(QString name, SequenceType sequenceType);
void DeleteSequence(CTrackViewSequence* pSequence);
Code/Editor/TrackView/TrackViewTrack.h
+1 -1
View File
@@ -27,7 +27,7 @@ public:
: m_bAllOfSameType(true)
, m_bHasRotationTrack(false) {}
unsigned int GetCount() const { return m_tracks.size(); }
unsigned int GetCount() const { return static_cast<unsigned int>(m_tracks.size()); }
CTrackViewTrack* GetTrack(const unsigned int index) { return m_tracks[index]; }
const CTrackViewTrack* GetTrack(const unsigned int index) const { return m_tracks[index]; }
Code/Editor/Undo/Undo.h
+2 -2
View File
@@ -61,12 +61,12 @@ public:
// Confetti: Get the size of m_undoObjects
virtual int GetCount() const
{
return m_undoObjects.size();
return static_cast<int>(m_undoObjects.size());
}
virtual bool IsEmpty() const { return m_undoObjects.empty(); };
virtual void Undo(bool bUndo)
{
for (int i = m_undoObjects.size() - 1; i >= 0; i--)
for (int i = static_cast<int>(m_undoObjects.size() - 1); i >= 0; i--)
{
m_undoObjects[i]->Undo(bUndo);
}
Code/Editor/ViewManager.h
+1 -1
View File
@@ -86,7 +86,7 @@ public:
//////////////////////////////////////////////////////////////////////////
//! Get number of currently existing viewports.
virtual int GetViewCount() { return m_viewports.size(); };
virtual int GetViewCount() { return static_cast<int>(m_viewports.size()); };
//! Get viewport by index.
//! @param index 0 <= index < GetViewportCount()
virtual CViewport* GetView(int index) { return m_viewports[index]; }
Code/Editor/ViewportTitleDlg.cpp
+4 -4
View File
@@ -953,13 +953,13 @@ void CViewportTitleDlg::CheckForCameraSpeedUpdate()
void CViewportTitleDlg::OnGridSnappingToggled()
{
m_gridSizeActionWidget->setEnabled(m_enableGridSnappingAction->isChecked());
MainWindow::instance()->GetActionManager()->GetAction(ID_SNAP_TO_GRID)->trigger();
MainWindow::instance()->GetActionManager()->GetAction(AzToolsFramework::SnapToGrid)->trigger();
}
void CViewportTitleDlg::OnAngleSnappingToggled()
{
m_angleSizeActionWidget->setEnabled(m_enableAngleSnappingAction->isChecked());
MainWindow::instance()->GetActionManager()->GetAction(ID_SNAPANGLE)->trigger();
MainWindow::instance()->GetActionManager()->GetAction(AzToolsFramework::SnapAngle)->trigger();
}
void CViewportTitleDlg::OnGridSpinBoxChanged(double value)
@@ -974,14 +974,14 @@ void CViewportTitleDlg::OnAngleSpinBoxChanged(double value)
void CViewportTitleDlg::UpdateOverFlowMenuState()
{
bool gridSnappingActive = MainWindow::instance()->GetActionManager()->GetAction(ID_SNAP_TO_GRID)->isChecked();
bool gridSnappingActive = MainWindow::instance()->GetActionManager()->GetAction(AzToolsFramework::SnapToGrid)->isChecked();
{
QSignalBlocker signalBlocker(m_enableGridSnappingAction);
m_enableGridSnappingAction->setChecked(gridSnappingActive);
}
m_gridSizeActionWidget->setEnabled(gridSnappingActive);
bool angleSnappingActive = MainWindow::instance()->GetActionManager()->GetAction(ID_SNAPANGLE)->isChecked();
bool angleSnappingActive = MainWindow::instance()->GetActionManager()->GetAction(AzToolsFramework::SnapAngle)->isChecked();
{
QSignalBlocker signalBlocker(m_enableAngleSnappingAction);
m_enableAngleSnappingAction->setChecked(angleSnappingActive);
Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp
+1 -1
View File
@@ -47,7 +47,7 @@ namespace AZ
}
auto stackEntry = AZStd::make_shared<BlockCache>(
cacheSize, blockSize, aznumeric_caster(hardware.m_maxPhysicalSectorSize), false);
cacheSize, aznumeric_cast<AZ::u32>(blockSize), aznumeric_cast<AZ::u32>(hardware.m_maxPhysicalSectorSize), false);
stackEntry->SetNext(AZStd::move(parent));
return stackEntry;
}
Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp
+1 -1
View File
@@ -45,7 +45,7 @@ namespace AZ
}
auto stackEntry = AZStd::make_shared<DedicatedCache>(
cacheSize, blockSize, aznumeric_caster(hardware.m_maxPhysicalSectorSize), m_writeOnlyEpilog);
cacheSize, aznumeric_cast<AZ::u32>(blockSize), aznumeric_cast<AZ::u32>(hardware.m_maxPhysicalSectorSize), m_writeOnlyEpilog);
stackEntry->SetNext(AZStd::move(parent));
return stackEntry;
}
Code/Framework/AzCore/AzCore/Math/Aabb.h
+1 -1
View File
@@ -43,7 +43,7 @@ namespace AZ
static Aabb CreateCenterRadius(const Vector3& center, float radius);
//! Creates an AABB which contains the specified points.
static Aabb CreatePoints(const Vector3* pts, int numPts);
static Aabb CreatePoints(const Vector3* pts, size_t numPts);
//! Creates an AABB which contains the specified OBB.
static Aabb CreateFromObb(const Obb& obb);
Code/Framework/AzCore/AzCore/Math/Aabb.inl
+2 -2
View File
@@ -60,10 +60,10 @@ namespace AZ
}
AZ_MATH_INLINE Aabb Aabb::CreatePoints(const Vector3* pts, int numPts)
AZ_MATH_INLINE Aabb Aabb::CreatePoints(const Vector3* pts, size_t numPts)
{
Aabb aabb = Aabb::CreateFromPoint(pts[0]);
for (int i = 1; i < numPts; ++i)
for (size_t i = 1; i < numPts; ++i)
{
aabb.AddPoint(pts[i]);
}
Code/Framework/AzCore/AzCore/Module/Environment.cpp
+38 -1
View File
@@ -11,6 +11,7 @@
#include <AzCore/Memory/OSAllocator.h>
#include <AzCore/std/containers/unordered_map.h>
#include <AzCore/Math/Crc.h>
#include <AzCore/std/parallel/scoped_lock.h>
namespace AZ
{
@@ -75,6 +76,42 @@ namespace AZ
bool operator==(const OSStdAllocator& a, const OSStdAllocator& b) { (void)a; (void)b; return true; }
bool operator!=(const OSStdAllocator& a, const OSStdAllocator& b) { (void)a; (void)b; return false; }
void EnvironmentVariableHolderBase::UnregisterAndDestroy(DestructFunc destruct, bool moduleRelease)
{
const bool releaseByUseCount = (--m_useCount == 0);
// We take over the lock, and release it before potentially destroying/freeing ourselves
{
AZStd::scoped_lock envLockHolder(AZStd::adopt_lock, m_mutex);
const bool releaseByModule = (moduleRelease && !m_canTransferOwnership && m_moduleOwner == AZ::Environment::GetModuleId());
if (!releaseByModule && !releaseByUseCount)
{
return;
}
// if the environment that created us is gone the owner can be null
// which means (assuming intermodule allocator) that the variable is still alive
// but can't be found as it's not part of any environment.
if (m_environmentOwner)
{
m_environmentOwner->RemoveVariable(m_guid);
m_environmentOwner = nullptr;
}
if (m_isConstructed)
{
destruct(this, DestroyTarget::Member); // destruct the value
}
}
// m_mutex is no longer held here, envLockHolder has released it above.
if (releaseByUseCount)
{
// m_mutex is unlocked before this is deleted
Environment::AllocatorInterface* allocator = m_allocator;
// Call child class dtor and clear the memory
destruct(this, DestroyTarget::Self);
allocator->DeAllocate(this);
}
}
// instance of the environment
EnvironmentInterface* EnvironmentInterface::s_environment = nullptr;
@@ -110,7 +147,7 @@ namespace AZ
#ifdef AZ_ENVIRONMENT_VALIDATE_ON_EXIT
AZ_Assert(m_numAttached == 0, "We should not delete an environment while there are %d modules attached! Unload all DLLs first!", m_numAttached);
#endif
for (auto variableIt : m_variableMap)
{
EnvironmentVariableHolderBase* holder = reinterpret_cast<EnvironmentVariableHolderBase*>(variableIt.second);
Code/Framework/AzCore/AzCore/Module/Environment.h
+29 -63
View File
@@ -200,6 +200,11 @@ namespace AZ
class EnvironmentVariableHolderBase
{
friend class EnvironmentImpl;
protected:
enum class DestroyTarget {
Member,
Self
};
public:
EnvironmentVariableHolderBase(u32 guid, AZ::Internal::EnvironmentInterface* environmentOwner, bool canOwnershipTransfer, Environment::AllocatorInterface* allocator)
: m_environmentOwner(environmentOwner)
@@ -217,12 +222,21 @@ namespace AZ
return m_isConstructed;
}
bool IsOwner() const
{
return m_moduleOwner == Environment::GetModuleId();
}
u32 GetId() const
{
return m_guid;
}
protected:
using DestructFunc = void (*)(EnvironmentVariableHolderBase *, DestroyTarget);
// Assumes the m_mutex is already locked.
// On return m_mutex is in an unlocked state.
void UnregisterAndDestroy(DestructFunc destruct, bool moduleRelease);
AZ::Internal::EnvironmentInterface* m_environmentOwner; ///< Used to know which environment we should use to free the variable if we can't transfer ownership
void* m_moduleOwner; ///< Used when the variable can't transfered across module and we need to destruct the variable when the module is going away
bool m_canTransferOwnership; ///< True if variable can be allocated in one module and freed in other. Usually true for POD types when they share allocator.
@@ -242,41 +256,29 @@ namespace AZ
memset(&m_value, 0, sizeof(T));
}
template <class... Args>
template<class... Args>
void ConstructImpl(const AZStd::false_type& /* AZStd::has_trivial_constructor<T> */, Args&&... args)
{
// Construction of non-trivial types is left up to the type's constructor.
new(&m_value) T(AZStd::forward<Args>(args)...);
}
void DestructImpl(const AZStd::true_type& /* AZStd::is_trivially_destructible<T> */)
static void DestructDispatchNoLock(EnvironmentVariableHolderBase *base, DestroyTarget selfDestruct)
{
// do nothing
}
void DestructImpl(const AZStd::false_type& /* AZStd::is_trivially_destructible<T> */)
{
reinterpret_cast<T*>(&m_value)->~T();
}
// Assumes the lock is already held
void UnregisterAndDestruct()
{
// if the environment that created us is gone the owner can be null
// which means (assuming intermodule allocator) that the variable is still alive
// but can't be found as it's not part of any environment.
if (m_environmentOwner)
auto *self = reinterpret_cast<EnvironmentVariableHolder *>(base);
if (selfDestruct == DestroyTarget::Self)
{
m_environmentOwner->RemoveVariable(m_guid);
m_environmentOwner = nullptr;
self->~EnvironmentVariableHolder();
return;
}
if (m_isConstructed)
AZ_Assert(self->m_isConstructed, "Variable is not constructed. Please check your logic and guard if needed!");
self->m_isConstructed = false;
self->m_moduleOwner = nullptr;
if constexpr(!AZStd::is_trivially_destructible_v<T>)
{
DestructNoLock();
reinterpret_cast<T*>(&self->m_value)->~T();
}
}
public:
EnvironmentVariableHolder(u32 guid, bool isOwnershipTransfer, Environment::AllocatorInterface* allocator)
: EnvironmentVariableHolderBase(guid, Environment::GetInstance(), isOwnershipTransfer, allocator)
@@ -287,12 +289,6 @@ namespace AZ
{
AZ_Assert(!m_isConstructed, "To get the destructor we should have already destructed the variable!");
}
bool IsOwner() const
{
return m_moduleOwner == Environment::GetModuleId();
}
void AddRef()
{
AZStd::lock_guard<AZStd::spin_mutex> lock(m_mutex);
@@ -303,30 +299,8 @@ namespace AZ
void Release()
{
m_mutex.lock();
if (--s_moduleUseCount == 0)
{
if (!m_canTransferOwnership && m_moduleOwner == AZ::Environment::GetModuleId())
{
UnregisterAndDestruct();
}
}
if (--m_useCount == 0)
{
UnregisterAndDestruct();
// unlock before this is deleted
m_mutex.unlock();
Environment::AllocatorInterface* allocator = m_allocator;
// Call dtor and clear the memory
this->~EnvironmentVariableHolder();
allocator->DeAllocate(this);
return;
}
m_mutex.unlock();
const bool moduleRelease = (--s_moduleUseCount == 0);
UnregisterAndDestroy(DestructDispatchNoLock, moduleRelease);
}
void Construct()
@@ -352,18 +326,10 @@ namespace AZ
}
}
void DestructNoLock()
{
AZ_Assert(m_isConstructed, "Variable is not constructed. Please check your logic and guard if needed!");
m_isConstructed = false;
m_moduleOwner = nullptr;
DestructImpl(typename AZStd::is_trivially_destructible<T>::type());
}
void Destruct()
{
AZStd::lock_guard<AZStd::spin_mutex> lock(m_mutex);
DestructNoLock();
DestructDispatchNoLock(this, DestroyTarget::Member);
}
// variable storage
Code/Framework/AzCore/AzCore/Serialization/Json/ByteStreamSerializer.cpp
+1 -1
View File
@@ -71,7 +71,7 @@ namespace AZ
if (context.ShouldKeepDefaults() || !defaultValue || (valAsByteStream != *static_cast<const JsonByteStream*>(defaultValue)))
{
const auto base64ByteStream = AZ::StringFunc::Base64::Encode(valAsByteStream.data(), valAsByteStream.size());
outputValue.SetString(base64ByteStream.c_str(), base64ByteStream.size(), context.GetJsonAllocator());
outputValue.SetString(base64ByteStream.c_str(), static_cast<rapidjson::SizeType>(base64ByteStream.size()), context.GetJsonAllocator());
return context.Report(Tasks::WriteValue, Outcomes::Success, "ByteStream successfully stored.");
}
Code/Framework/AzCore/AzCore/std/chrono/types.h
+1 -1
View File
@@ -211,7 +211,7 @@ namespace AZStd
// 20.9.3.2, observer:
constexpr rep count() const { return m_rep; }
// 20.9.3.3, arithmetic:
constexpr duration operator+() const { *this; }
constexpr duration operator+() const { return *this; }
constexpr duration operator-() const { return duration(-m_rep); }
constexpr duration& operator++() { ++m_rep; return *this; }
constexpr duration operator++(int) { return duration(m_rep++); }
Code/Framework/AzCore/AzCore/std/containers/ring_buffer.h
+1 -1
View File
@@ -1056,7 +1056,7 @@ namespace AZStd
inline void insert(const iterator& pos, ForwardIterator first, ForwardIterator last, const AZStd::forward_iterator_tag&)
{
size_type size = AZStd::distance(first, last);
AZSTD_CONTAINER_ASSERT(size >= 0, "AZStd::ring_buffer::insert - there are no elements to insert!");
AZSTD_CONTAINER_ASSERT(first > last, "AZStd::ring_buffer::insert - there are no elements to insert!");
if (size == 0)
{
return;
Code/Framework/AzCore/AzCore/std/hash.cpp
+1
View File
@@ -21,6 +21,7 @@ namespace AZStd
1610612741ul, 3221225473ul, 4294967291ul
};
// Bucket size suitable to hold n elements.
AZStd::size_t hash_next_bucket_size(AZStd::size_t n)
{
const AZStd::size_t* first = prime_list;
Code/Framework/AzCore/AzCore/std/hash_table.h
+42 -26
View File
@@ -134,6 +134,7 @@ namespace AZStd
void rehash(HashTable* table, size_type numBucketsMin)
{
size_type num_buckets = 0;
numBucketsMin = (AZStd::max)(numBucketsMin, (size_type)ceilf((float)m_list.size() / m_max_load_factor));
if (numBucketsMin != 0)
@@ -143,7 +144,7 @@ namespace AZStd
if (num_buckets == m_numBuckets)
{
return; // no point
return; // no need yet to rehash
}
m_numBuckets = num_buckets;
@@ -165,32 +166,43 @@ namespace AZStd
while (!m_list.empty())
{
cur = m_list.begin();
typename list_type::iterator insertIter, curEnd(cur);
const typename HashTable::key_type& valueKey = Traits::key_from_value(*cur);
typename list_type::iterator newIter, iter(cur);
size_type numValues = 1;
for (++iter; iter != last && table->m_keyEqual(Traits::key_from_value(*cur), Traits::key_from_value(*iter)); ++iter, ++numValues)
// Get the number of same consecutive elements in the table with same key,
// this allows range insertion of elements at once
for (++curEnd; curEnd != last && table->m_keyEqual(valueKey, Traits::key_from_value(*curEnd)); ++curEnd, ++numValues)
{
}
;
const typename HashTable::key_type& valueKey = Traits::key_from_value(*cur);
size_type newBucketIndex = table->bucket_from_hash(table->m_hasher(valueKey));
// newBucket.first holds the total number of elements in the bucket
// newBucket.second contains the pointer to the first element in the bucket
vector_value_type& newBucket = newBuckets[newBucketIndex];
size_type numElements = newBucket.first;
newIter = newBucket.second;
insertIter = newBucket.second;
// If we don't have elements in the bucket yet, transfer the elements directly
if (numElements == 0)
{
newList.splice(newList.begin(), m_list, cur, iter);
newList.splice(newList.begin(), m_list, cur, curEnd);
newBucket.second = newList.begin();
}
else
{
if (!table->find_insert_position(valueKey, table->m_keyEqual, newIter, numElements, integral_constant<bool, Traits::has_multi_elements>()))
// Since there are elements already in the bucket, update `insertIter` to where the elements will need to be inserted.
if (!table->find_insert_position(valueKey, table->m_keyEqual, insertIter, numElements, integral_constant<bool, Traits::has_multi_elements>()))
{
continue;
// An element was found but we don't allow for duplicate elements in this table.
// This happens when there was an insertion of two elements that are equal but have different hashes,
// which is undefined behavior for a hash table: ISO C++ N4713, section 23.14.15 - 5.3
AZ_Assert(false, "Found a duplicate element when rehashing. "
"Review the hashing function for this type and make sure two equal elements always have the same hash");
}
newList.splice(newIter, m_list, cur, iter);
newList.splice(insertIter, m_list, cur, curEnd);
}
newBucket.first += numValues;
@@ -251,15 +263,15 @@ namespace AZStd
m_vector.set_allocator(typename vector_type::allocator_type(&m_allocator));
}
allocator_type m_allocator; ///< The single instance of the allocator shared between list and vector containers.
list_type m_list; ///< List with elements.
vector_type m_vector; ///< Buckets with list iterators.
allocator_type m_allocator; //!< The single instance of the allocator shared between list and vector containers.
list_type m_list; //!< List with elements.
vector_type m_vector; //!< Buckets with list iterators.
private:
vector_value_type* m_buckets; ///< Current buckets array. (can point to the m_vector or m_startBucket).
size_type m_numBuckets; ///< Current number of buckets.
float m_max_load_factor;
vector_value_type m_startBucket; ///< Start bucket used for before we start dynamically allocate memory from m_vector.
vector_value_type* m_buckets; //!< Current buckets array. (can point to the m_vector or m_startBucket).
size_type m_numBuckets; //!< Current number of buckets.
float m_max_load_factor; //!< Maximum load (elements/buckets) before rehashing.
vector_value_type m_startBucket; //!< Start bucket used for before we start dynamically allocate memory from m_vector.
};
/**
@@ -321,8 +333,8 @@ namespace AZStd
template<class HashTable>
AZ_FORCE_INLINE void rehash(HashTable*, size_type) {}
vector_type m_vector; ///< Buckets with list iterators.
list_type m_list; ///< List with elements.
vector_type m_vector; //!< Buckets with list iterators.
list_type m_list; //!< List with elements.
};
}
@@ -972,28 +984,32 @@ namespace AZStd
rhs.clear();
}
// find_insert_position sets insertIter to where the element should be inserted
// and returns true if the element should be inserted, otherwise false
template<class ComparableToKey, class KeyEq>
bool find_insert_position(const ComparableToKey& keyCmp, const KeyEq& keyEq, iterator& iter, size_type numElements, const true_type& /* is multi elements */)
bool find_insert_position(const ComparableToKey& keyCmp, const KeyEq& keyEq, iterator& insertIter, size_type numElements, const true_type& /* is multi elements */)
{
for (size_type i = 0; i < numElements; ++i, ++iter)
for (size_type i = 0; i < numElements; ++i, ++insertIter)
{
if (keyEq(keyCmp, Traits::key_from_value(*iter)))
if (keyEq(keyCmp, Traits::key_from_value(*insertIter)))
{
++iter;
++insertIter;
break;
}
}
// always return true since multi elements (like multiset) allow repeated elements
return true;
}
template<class ComparableToKey, class KeyEq>
bool find_insert_position(const ComparableToKey& keyCmp, const KeyEq& keyEq, iterator& iter, size_type numElements, const false_type& /* !is multi elements */)
bool find_insert_position(const ComparableToKey& keyCmp, const KeyEq& keyEq, iterator& insertIter, size_type numElements, const false_type& /* !is multi elements */)
{
for (size_type i = 0; i < numElements; ++i, ++iter)
for (size_type i = 0; i < numElements; ++i, ++insertIter)
{
if (keyEq(keyCmp, Traits::key_from_value(*iter)))
if (keyEq(keyCmp, Traits::key_from_value(*insertIter)))
{
// Element already exists, it shouldn't be inserted as we don't allow more than one repeated element for this specialization
return false;
}
}
Code/Framework/AzCore/AzCore/std/utils.h
+1 -1
View File
@@ -294,7 +294,7 @@ namespace AZStd
T& m_v;
constexpr addr_impl_ref(T& v)
: m_v(v) {}
constexpr addr_impl_ref& operator=(const addr_impl_ref& v) { m_v = v; }
constexpr addr_impl_ref& operator=(const addr_impl_ref& v) { m_v = v; return *this; }
constexpr operator T& () const { return m_v; }
};
Code/Framework/AzCore/Tests/AZStd/Hashed.cpp
+49
View File
@@ -287,6 +287,55 @@ namespace UnitTest
}
}
TEST_F(HashedContainers, HashTable_InsertionDuplicateOnRehash)
{
struct TwoPtrs
{
void* m_ptr1;
void* m_ptr2;
bool operator==(const TwoPtrs& other) const
{
if (m_ptr1 == other.m_ptr1)
{
return m_ptr2 == other.m_ptr2;
}
else if (m_ptr1 == other.m_ptr2)
{
return m_ptr2 == other.m_ptr1;
}
return false;
}
};
// This hashing function produces different hashes for two equal values,
// which violates the requirement for hashing functions.
// The test makes sure that this does not reproduce an issue that caused the insert() function to loop infinitely.
struct TwoPtrsHasher
{
size_t operator()(const TwoPtrs& p) const
{
size_t hash{ 0 };
AZStd::hash_combine(hash, p.m_ptr1, p.m_ptr2);
return hash;
}
};
using PairSet = AZStd::unordered_set<TwoPtrs, TwoPtrsHasher>;
PairSet set;
set.insert({ (void*)1, (void*)2 });
set.insert({ (void*)3, (void*)4 });
set.insert({ (void*)5, (void*)6 });
set.insert({ (void*)7, (void*)8 });
// Elements with different hashes, but equal
set.insert({ (void*)0x000001ceddd9ca20, (void*)0x000001ceddd9cba0 }); // hash(148335135725641)
set.insert({ (void*)0x000001ceddd9cba0, (void*)0x000001ceddd9ca20 }); // hash(148335135764189)
AZ_TEST_START_TRACE_SUPPRESSION;
// This will trigger the assertion of duplicated elements found
// A bucket size of 23 since is where the collision between different hashes happens
set.rehash(23);
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // 1 assertion
}
TEST_F(HashedContainers, HashTable_Fixed)
{
array<int, 5> elements = {
Code/Framework/AzCore/Tests/Asset/AssetManagerLoadingTests.cpp
+1 -1
View File
@@ -1150,7 +1150,7 @@ namespace UnitTest
#if AZ_TRAIT_DISABLE_FAILED_ASSET_MANAGER_TESTS
TEST_F(AssetJobsFloodTest, DISABLED_ContainerFilterTest_ContainersWithAndWithoutFiltering_Success)
#else
TEST_F(AssetJobsFloodTest, ContainerFilterTest_ContainersWithAndWithoutFiltering_Success)
TEST_F(AssetJobsFloodTest, DISABLED_ContainerFilterTest_ContainersWithAndWithoutFiltering_Success)
#endif // !AZ_TRAIT_DISABLE_FAILED_ASSET_MANAGER_TESTS
{
m_assetHandlerAndCatalog->AssetCatalogRequestBus::Handler::BusConnect();
Code/Framework/AzFramework/AzFramework/Asset/AssetSystemComponentHelper.cpp
+5 -1
View File
@@ -163,7 +163,11 @@ namespace AzFramework
AZ_TracePrintfOnce("AssetSystemComponent", "Failed to find asset platform, setting 'pc'\n");
outputConnectionSettings.m_assetPlatform = "pc";
}
outputConnectionSettings.m_assetPlatform = assetsPlatform;
else
{
outputConnectionSettings.m_assetPlatform = assetsPlatform;
}
if (outputConnectionSettings.m_assetPlatform.empty())
{
assetsPlatform = AzFramework::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.cpp
+2
View File
@@ -227,8 +227,10 @@ namespace AzFramework
EntitySpawnTicket::EntitySpawnTicket(EntitySpawnTicket&& rhs)
: m_payload(rhs.m_payload)
, m_id(rhs.m_id)
{
rhs.m_payload = nullptr;
rhs.m_id = 0;
}
EntitySpawnTicket::EntitySpawnTicket(AZ::Data::Asset<Spawnable> spawnable)
Code/Framework/AzFramework/Platform/Linux/AzFramework/Process/ProcessWatcher_Linux.cpp
+1 -1
View File
@@ -269,7 +269,7 @@ namespace AzFramework
int numEnvironmentVars = 0;
if (processLaunchInfo.m_environmentVariables)
{
const int numEnvironmentVars = processLaunchInfo.m_environmentVariables->size();
numEnvironmentVars = processLaunchInfo.m_environmentVariables->size();
// Adding one more as exec expects the array to have a nullptr as the last element
environmentVariables = new char*[numEnvironmentVars + 1];
for (int i = 0; i < numEnvironmentVars; i++)
Code/Framework/AzFramework/Tests/OctreeTests.cpp
+3 -3
View File
@@ -98,7 +98,7 @@ namespace UnitTest
// If an entry is removed from the octree as an unintended side effect of updating an existing entry,
// GetEntryCount can't be relied upon to report the actual entry count.
// So manually count the entries when using the entry count for validation.
uint32_t manualEntryCount = 0;
size_t manualEntryCount = 0;
visScene->EnumerateNoCull([&manualEntryCount](const AzFramework::IVisibilityScene::NodeData& nodeData) { manualEntryCount += nodeData.m_entries.size(); });
EXPECT_EQ(manualEntryCount, expectedEntryCount);
@@ -409,7 +409,7 @@ namespace UnitTest
}
// Expect all the entries to be in the scene
ValidateEntryCountEqualsExpectedCount(m_octreeScene, visEntries.size());
ValidateEntryCountEqualsExpectedCount(m_octreeScene, static_cast<uint32_t>(visEntries.size()));
// Update them, without making any actual changes
for (AzFramework::VisibilityEntry& entry : visEntries)
@@ -418,6 +418,6 @@ namespace UnitTest
}
// Expect all the entries to be in the scene
ValidateEntryCountEqualsExpectedCount(m_octreeScene, visEntries.size());
ValidateEntryCountEqualsExpectedCount(m_octreeScene, static_cast<uint32_t>(visEntries.size()));
}
}
Code/Framework/AzFramework/Tests/Spawnable/SpawnableEntitiesManagerTests.cpp
+18
View File
@@ -366,6 +366,24 @@ namespace UnitTest
}
}
TEST_F(SpawnableEntitiesManagerTest, EntitySpawnTicket_Move_Works)
{
AzFramework::EntitySpawnTicket ticket1(*m_spawnableAsset);
AzFramework::EntitySpawnTicket ticket2(*m_spawnableAsset);
const AzFramework::EntitySpawnTicket::Id ticket1Id = ticket1.GetId();
const AzFramework::EntitySpawnTicket::Id ticket2Id = ticket2.GetId();
AzFramework::EntitySpawnTicket ticketMoveConstructor(AZStd::move(ticket1));
EXPECT_TRUE(ticketMoveConstructor.IsValid());
EXPECT_EQ(ticketMoveConstructor.GetId(), ticket1Id);
AzFramework::EntitySpawnTicket ticketMoveOperator;
ticketMoveOperator = AZStd::move(ticket2);
EXPECT_TRUE(ticketMoveOperator.IsValid());
EXPECT_EQ(ticketMoveOperator.GetId(), ticket2Id);
}
TEST_F(SpawnableEntitiesManagerTest, SpawnAllEntities_DeleteTicketBeforeCall_NoCrash)
{
{
Code/Framework/AzNetworking/AzNetworking/Framework/INetworkInterface.h
+8
View File
@@ -103,6 +103,14 @@ namespace AzNetworking
//! @return boolean true on success
virtual bool Disconnect(ConnectionId connectionId, DisconnectReason reason) = 0;
//! Sets whether this connection interface can disconnect by virtue of a timeout
//! @param timeoutEnabled If this connection interface will automatically disconnect due to a timeout
virtual void SetTimeoutEnabled(bool timeoutEnabled) = 0;
//! Whether this connection interface will disconnect by virtue of a time out (does not account for cvars affecting all connections)
//! @return boolean true if this connection will not disconnect on timeout (does not account for cvars affecting all connections)
virtual bool IsTimeoutEnabled() const = 0;
//! Const access to the metrics tracked by this network interface.
//! @return const reference to the metrics tracked by this network interface
const NetworkInterfaceMetrics& GetMetrics() const;
Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpConnection.cpp
+4 -4
View File
@@ -170,7 +170,7 @@ namespace AzNetworking
}
timeoutItem->UpdateTimeoutTime(startTimeMs);
NetworkOutputSerializer serializer(buffer.GetBuffer(), buffer.GetSize());
NetworkOutputSerializer serializer(buffer.GetBuffer(), static_cast<uint32_t>(buffer.GetSize()));
if (m_state == ConnectionState::Connecting)
{
const ConnectResult connectResult = m_networkInterface.GetConnectionListener().ValidateConnect(GetRemoteAddress(), header, serializer);
@@ -198,7 +198,7 @@ namespace AzNetworking
{
TcpPacketEncodingBuffer buffer;
{
NetworkInputSerializer serializer(buffer.GetBuffer(), buffer.GetCapacity());
NetworkInputSerializer serializer(buffer.GetBuffer(), static_cast<uint32_t>(buffer.GetCapacity()));
if (!const_cast<IPacket&>(packet).Serialize(serializer))
{
AZ_Assert(false, "SendReliablePacket: Unable to serialize packet [Type: %d]", packet.GetPacketType());
@@ -272,7 +272,7 @@ namespace AzNetworking
{
TcpPacketHeader header(packetType, aznumeric_cast<uint16_t>(payloadBuffer.GetSize()));
header.SetPacketFlag(PacketFlag::Compressed, shouldCompress);
NetworkInputSerializer serializer(headerBuffer.GetBuffer(), headerBuffer.GetCapacity());
NetworkInputSerializer serializer(headerBuffer.GetBuffer(), static_cast<uint32_t>(headerBuffer.GetCapacity()));
if (!header.Serialize(serializer))
{
return false;
@@ -313,7 +313,7 @@ namespace AzNetworking
m_networkInterface.GetMetrics().m_sendBytesCompressedDelta += (payloadSize - compressionMemBytesUsed);
writeBuffer.Resize(aznumeric_cast<int32_t>(compressionMemBytesUsed));
payloadSize = writeBuffer.GetSize();
payloadSize = static_cast<uint32_t>(writeBuffer.GetSize());
srcData = writeBuffer.GetBuffer();
}
Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpNetworkInterface.cpp
+11 -1
View File
@@ -174,6 +174,16 @@ namespace AzNetworking
return connection->Disconnect(reason, TerminationEndpoint::Local);
}
void TcpNetworkInterface::SetTimeoutEnabled(bool timeoutEnabled)
{
m_timeoutEnabled = timeoutEnabled;
}
bool TcpNetworkInterface::IsTimeoutEnabled() const
{
return m_timeoutEnabled;
}
void TcpNetworkInterface::QueueNewConnection(const PendingConnection& pendingConnection)
{
m_pendingConnections.PushBackItem(pendingConnection);
@@ -306,7 +316,7 @@ namespace AzNetworking
{
tcpConnection->SendReliablePacket(CorePackets::HeartbeatPacket());
}
else if (net_TcpTimeoutConnections)
else if (net_TcpTimeoutConnections && m_networkInterface.IsTimeoutEnabled())
{
tcpConnection->Disconnect(DisconnectReason::Timeout, TerminationEndpoint::Local);
return TimeoutResult::Delete;
Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpNetworkInterface.h
+3
View File
@@ -99,6 +99,8 @@ namespace AzNetworking
bool WasPacketAcked(ConnectionId connectionId, PacketId packetId) override;
bool StopListening() override;
bool Disconnect(ConnectionId connectionId, DisconnectReason reason) override;
void SetTimeoutEnabled(bool timeoutEnabled) override;
bool IsTimeoutEnabled() const override;
//! @}
//! Queues a new incoming connection for this network interface.
@@ -154,6 +156,7 @@ namespace AzNetworking
AZ::Name m_name;
TrustZone m_trustZone;
uint16_t m_port = 0;
bool m_timeoutEnabled = true;
IConnectionListener& m_connectionListener;
TcpConnectionSet m_connectionSet;
TcpSocketManager m_tcpSocketManager;
Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpRingBuffer.inl
+1 -1
View File
@@ -12,7 +12,7 @@ namespace AzNetworking
{
template <uint32_t SIZE>
inline TcpRingBuffer<SIZE>::TcpRingBuffer()
: m_impl(m_buffer.data(), m_buffer.size())
: m_impl(m_buffer.data(), static_cast<uint32_t>(m_buffer.size()))
{
;
}
Code/Framework/AzNetworking/AzNetworking/UdpTransport/DtlsEndpoint.cpp
+2 -2
View File
@@ -84,7 +84,7 @@ namespace AzNetworking
if (dtlsData.GetSize() > 0)
{
const uint8_t* encryptedData = dtlsData.GetBuffer();
const uint32_t encryptedSize = dtlsData.GetSize();
const uint32_t encryptedSize = static_cast<uint32_t>(dtlsData.GetSize());
BIO_write(m_readBio, encryptedData, encryptedSize);
}
DtlsEndpoint::HandshakeState prevState = m_state;
@@ -196,7 +196,7 @@ namespace AzNetworking
// Need to do this... connection negotiation may have left data in the write bio that we need to send out
if (BIO_ctrl_pending(m_writeBio) > 0)
{
const uint32_t maxBufferSize = outHandshakeData.GetCapacity();
const uint32_t maxBufferSize = static_cast<uint32_t>(outHandshakeData.GetCapacity());
outHandshakeData.Resize(maxBufferSize);
const int32_t dataSize = BIO_read(m_writeBio, outHandshakeData.GetBuffer(), maxBufferSize);
outHandshakeData.Resize(dataSize);
Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpFragmentQueue.cpp
+3 -3
View File
@@ -108,7 +108,7 @@ namespace AzNetworking
return true;
}
totalPacketSize += packetFragments[index]->GetChunkBuffer().GetSize();
totalPacketSize += static_cast<uint32_t>(packetFragments[index]->GetChunkBuffer().GetSize());
}
// We now mark this sequence as delivered, so if by some chance all the individual chunks get redelivered again we don't double deliver the reconstructed packet
@@ -125,7 +125,7 @@ namespace AzNetworking
uint8_t* bufferPointer = buffer.GetBuffer();
for (uint32_t index = 0; index < packetFragments.size(); ++index)
{
const uint32_t chunkSize = packetFragments[index]->GetChunkBuffer().GetSize();
const uint32_t chunkSize = static_cast<uint32_t>(packetFragments[index]->GetChunkBuffer().GetSize());
memcpy(bufferPointer, packetFragments[index]->GetChunkBuffer().GetBuffer(), chunkSize);
bufferPointer += chunkSize;
}
@@ -133,7 +133,7 @@ namespace AzNetworking
// We can erase all the chunks now, packet is completed
m_packetFragments.erase(fragmentSequence);
NetworkOutputSerializer networkSerializer(buffer.GetBuffer(), buffer.GetSize());
NetworkOutputSerializer networkSerializer(buffer.GetBuffer(), static_cast<uint32_t>(buffer.GetSize()));
{
ISerializer& networkISerializer = networkSerializer; // To get the default typeinfo parameters in ISerializer
Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpNetworkInterface.cpp
+17 -7
View File
@@ -249,7 +249,7 @@ namespace AzNetworking
continue;
}
decodedPacketData = m_decompressBuffer.GetBuffer();
decodedPacketSize = m_decompressBuffer.GetSize();
decodedPacketSize = static_cast<int32_t>(m_decompressBuffer.GetSize());
}
GetMetrics().m_recvBytesUncompressed += decodedPacketSize;
@@ -397,6 +397,16 @@ namespace AzNetworking
return connection->Disconnect(reason, TerminationEndpoint::Local);
}
void UdpNetworkInterface::SetTimeoutEnabled(bool timeoutEnabled)
{
m_timeoutEnabled = timeoutEnabled;
}
bool UdpNetworkInterface::IsTimeoutEnabled() const
{
return m_timeoutEnabled;
}
bool UdpNetworkInterface::IsEncrypted() const
{
return m_socket->IsEncrypted();
@@ -494,7 +504,7 @@ namespace AzNetworking
{
buffer.Resize(buffer.GetCapacity());
NetworkInputSerializer networkSerializer(buffer.GetBuffer(), buffer.GetCapacity());
NetworkInputSerializer networkSerializer(buffer.GetBuffer(), static_cast<uint32_t>(buffer.GetCapacity()));
ISerializer& serializer = networkSerializer; // To get the default typeinfo parameters in ISerializer
if (!header.SerializePacketFlags(serializer))
@@ -517,7 +527,7 @@ namespace AzNetworking
buffer.Resize(serializer.GetSize());
}
uint32_t packetSize = buffer.GetSize();
uint32_t packetSize = static_cast<uint32_t>(buffer.GetSize());
uint8_t* packetData = buffer.GetBuffer();
// If the packet doesn't fit within our MTU (minus potential SSL encryption overhead), break it up
@@ -549,7 +559,7 @@ namespace AzNetworking
UdpPacketEncodingBuffer writeBuffer;
if (m_compressor && shouldCompress)
{
NetworkInputSerializer flagSerializer(writeBuffer.GetBuffer(), writeBuffer.GetCapacity());
NetworkInputSerializer flagSerializer(writeBuffer.GetBuffer(), static_cast<uint32_t>(writeBuffer.GetCapacity()));
ISerializer& serializer = flagSerializer; // To get the default typeinfo parameters in ISerializer
header.SetPacketFlag(PacketFlag::Compressed, true);
@@ -562,7 +572,7 @@ namespace AzNetworking
AZ_Assert(flagSize == 1, "Flag bitfield should serialize to one byte");
// Compress the packet, make sure to offset by the size of the flag which is now serialized
const uint32_t payloadSize = buffer.GetSize() - flagSize;
const uint32_t payloadSize = static_cast<uint32_t>(buffer.GetSize() - flagSize);
uint8_t* payload = buffer.GetBuffer() + flagSize;
const AZStd::size_t maxSizeNeeded = m_compressor->GetMaxCompressedBufferSize(payloadSize);
AZStd::size_t compressionMemBytesUsed = 0;
@@ -578,7 +588,7 @@ namespace AzNetworking
if (compressionMemBytesUsed < payloadSize)
{
writeBuffer.Resize(aznumeric_cast<int32_t>(flagSize + compressionMemBytesUsed));
packetSize = writeBuffer.GetSize();
packetSize = static_cast<uint32_t>(writeBuffer.GetSize());
packetData = writeBuffer.GetBuffer();
// Track byte delta caused by compression
GetMetrics().m_sendBytesCompressedDelta += (packetSize - compressionMemBytesUsed);
@@ -729,7 +739,7 @@ namespace AzNetworking
{
udpConnection->SendUnreliablePacket(CorePackets::HeartbeatPacket());
}
else if (net_UdpTimeoutConnections)
else if (net_UdpTimeoutConnections && m_networkInterface.IsTimeoutEnabled())
{
udpConnection->Disconnect(DisconnectReason::Timeout, TerminationEndpoint::Local);
return TimeoutResult::Delete;
Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpNetworkInterface.h
+3
View File
@@ -104,6 +104,8 @@ namespace AzNetworking
bool WasPacketAcked(ConnectionId connectionId, PacketId packetId) override;
bool StopListening() override;
bool Disconnect(ConnectionId connectionId, DisconnectReason reason) override;
void SetTimeoutEnabled(bool timeoutEnabled) override;
bool IsTimeoutEnabled() const override;
//! @}
//! Returns true if this is an encrypted socket, false if not.
@@ -179,6 +181,7 @@ namespace AzNetworking
TrustZone m_trustZone;
uint16_t m_port = 0;
bool m_allowIncomingConnections = false;
bool m_timeoutEnabled = true;
IConnectionListener& m_connectionListener;
UdpConnectionSet m_connectionSet;
TimeoutQueue m_connectionTimeoutQueue;
Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpReaderThread.cpp
+1 -1
View File
@@ -177,7 +177,7 @@ namespace AzNetworking
}
IpAddress address;
const uint32_t bufferHead = receiveBuffer.GetSize();
const uint32_t bufferHead = static_cast<uint32_t>(receiveBuffer.GetSize());
if (bufferHead + MaxUdpTransmissionUnit >= receiveBuffer.GetCapacity())
{
AZLOG_INFO("Receive buffer full, leaving data on the socket. Size exceeded by %d",
Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpSocket.cpp
+1 -1
View File
@@ -241,7 +241,7 @@ namespace AzNetworking
#ifdef ENABLE_LATENCY_DEBUG
int32_t UdpSocket::SendInternalDeferred(const DeferredData& data) const
{
return SendInternal(data.m_address, data.m_dataBuffer.GetBuffer(), data.m_dataBuffer.GetSize(), data.m_encrypt, *data.m_dtlsEndpoint);
return SendInternal(data.m_address, data.m_dataBuffer.GetBuffer(), static_cast<uint32_t>(data.m_dataBuffer.GetSize()), data.m_encrypt, *data.m_dtlsEndpoint);
}
#endif
}
Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.h
+1 -1
View File
@@ -98,7 +98,7 @@ namespace AzToolsFramework
SourceControlFileInfo GetSceneSourceControlInfo() override;
bool AreAnyEntitiesSelected() override { return !m_selectedEntities.empty(); }
int GetSelectedEntitiesCount() override { return m_selectedEntities.size(); }
int GetSelectedEntitiesCount() override { return static_cast<int>(m_selectedEntities.size()); }
const EntityIdList& GetSelectedEntities() override { return m_selectedEntities; }
const EntityIdList& GetHighlightedEntities() override { return m_highlightedEntities; }
void SetSelectedEntities(const EntityIdList& selectedEntities) override;
Code/Framework/AzToolsFramework/AzToolsFramework/Asset/AssetUtils.cpp
-2
View File
@@ -34,8 +34,6 @@ namespace AzToolsFramework::AssetUtils::Internal
return {};
}
const int pathLen = sourceFolder.length() + 1;
AZ::IO::Path sourceWildcard{ sourceFolder };
Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
+2 -9
View File
@@ -72,15 +72,8 @@ namespace AzToolsFramework
if (m_rootInstance != nullptr)
{
// Need to save off the template id to remove the template after the instance is deleted.
Prefab::TemplateId templateId = m_rootInstance->GetTemplateId();
m_rootInstance.reset();
if (templateId != Prefab::InvalidTemplateId)
{
// Remove the template here so that if we're in a Deactivate/Activate cycle, it can recreate the template/rootInstance
// correctly
m_prefabSystemComponent->RemoveTemplate(templateId);
}
m_prefabSystemComponent->RemoveAllTemplates();
}
}
@@ -95,7 +88,7 @@ namespace AzToolsFramework
if (templateId != Prefab::InvalidTemplateId)
{
m_rootInstance->SetTemplateId(Prefab::InvalidTemplateId);
m_prefabSystemComponent->RemoveTemplate(templateId);
m_prefabSystemComponent->RemoveAllTemplates();
}
m_rootInstance->SetContainerEntityName("Level");
}
Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceToTemplatePropagator.cpp
+1 -1
View File
@@ -164,7 +164,7 @@ namespace AzToolsFramework
AZStd::string path = prefix + pathIter->value.GetString();
pathIter->value.SetString(path.c_str(), path.length(), providedPatch.GetAllocator());
pathIter->value.SetString(path.c_str(), static_cast<rapidjson::SizeType>(path.length()), providedPatch.GetAllocator());
}
}
Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceUpdateExecutor.cpp
+1 -1
View File
@@ -97,7 +97,7 @@ namespace AzToolsFramework
m_updatingTemplateInstancesInQueue = true;
const int instanceCountToUpdateInBatch =
m_instanceCountToUpdateInBatch == 0 ? m_instancesUpdateQueue.size() : m_instanceCountToUpdateInBatch;
m_instanceCountToUpdateInBatch == 0 ? static_cast<int>(m_instancesUpdateQueue.size()) : m_instanceCountToUpdateInBatch;
TemplateId currentTemplateId = InvalidTemplateId;
TemplateReference currentTemplateReference = AZStd::nullopt;
Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
+3 -3
View File
@@ -1458,7 +1458,7 @@ namespace AzToolsFramework
if (&owningInstance->get() == &commonRootEntityOwningInstance)
{
// If it's the same instance, we can add this entity to the new instance entities.
int priorEntitiesSize = entities.size();
size_t priorEntitiesSize = entities.size();
entities.insert(entity);
@@ -1645,7 +1645,7 @@ namespace AzToolsFramework
entityDomAfter.Parse(newEntityDomString.toUtf8().constData());
// Add the new Entity DOM to the Entities member of the instance
rapidjson::Value aliasName(newEntityAlias.c_str(), newEntityAlias.length(), domToAddDuplicatedEntitiesUnder.GetAllocator());
rapidjson::Value aliasName(newEntityAlias.c_str(), static_cast<rapidjson::SizeType>(newEntityAlias.length()), domToAddDuplicatedEntitiesUnder.GetAllocator());
entitiesIter->value.AddMember(AZStd::move(aliasName), entityDomAfter, domToAddDuplicatedEntitiesUnder.GetAllocator());
}
@@ -1717,7 +1717,7 @@ namespace AzToolsFramework
nestedInstanceDomAfter.Parse(newInstanceDomString.toUtf8().constData());
// Add the new Instance DOM to the Instances member of the instance
rapidjson::Value aliasName(newInstanceAlias.c_str(), newInstanceAlias.length(), domToAddDuplicatedInstancesUnder.GetAllocator());
rapidjson::Value aliasName(newInstanceAlias.c_str(), static_cast<rapidjson::SizeType>(newInstanceAlias.length()), domToAddDuplicatedInstancesUnder.GetAllocator());
instancesIter->value.AddMember(AZStd::move(aliasName), nestedInstanceDomAfter, domToAddDuplicatedInstancesUnder.GetAllocator());
}
Code/Framework/AzToolsFramework/AzToolsFramework/PythonTerminal/ScriptHelpDialog.cpp
+1 -1
View File
@@ -251,7 +251,7 @@ namespace AzToolsFramework
{
EditorPythonConsoleInterface::GlobalFunctionCollection globalFunctionCollection;
editorPythonConsoleInterface->GetGlobalFunctionList(globalFunctionCollection);
m_items.reserve(globalFunctionCollection.size());
m_items.reserve(static_cast<int>(globalFunctionCollection.size()));
for (const EditorPythonConsoleInterface::GlobalFunction& globalFunction : globalFunctionCollection)
{
Item item;
Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.cpp
+1 -1
View File
@@ -247,7 +247,7 @@ namespace AzToolsFramework
if (highlightTextIndex >= 0)
{
const QString BACKGROUND_COLOR{ "#707070" };
label.insert(highlightTextIndex + m_filterString.length(), "</span>");
label.insert(highlightTextIndex + static_cast<int>(m_filterString.length()), "</span>");
label.insert(highlightTextIndex, "<span style=\"background-color: " + BACKGROUND_COLOR + "\">");
}
} while(highlightTextIndex > 0);
Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp
+6 -6
View File
@@ -2643,22 +2643,22 @@ namespace AzToolsFramework
m_gui->m_statusComboBox->setItalic(false);
if (allActive)
{
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[StatusTypeToIndex(StatusType::StatusStartActive)]);
m_gui->m_statusComboBox->setCurrentIndex(StatusTypeToIndex(StatusType::StatusStartActive));
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[static_cast<int>(StatusTypeToIndex(StatusType::StatusStartActive))]);
m_gui->m_statusComboBox->setCurrentIndex(static_cast<int>(StatusTypeToIndex(StatusType::StatusStartActive)));
m_comboItems[StatusTypeToIndex(StatusType::StatusStartActive)]->setCheckState(Qt::Checked);
}
else
if (allInactive)
{
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[StatusTypeToIndex(StatusType::StatusStartInactive)]);
m_gui->m_statusComboBox->setCurrentIndex(StatusTypeToIndex(StatusType::StatusStartInactive));
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[static_cast<int>(StatusTypeToIndex(StatusType::StatusStartInactive))]);
m_gui->m_statusComboBox->setCurrentIndex(static_cast<int>(StatusTypeToIndex(StatusType::StatusStartInactive)));
m_comboItems[StatusTypeToIndex(StatusType::StatusStartInactive)]->setCheckState(Qt::Checked);
}
else
if (allEditorOnly)
{
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[StatusTypeToIndex(StatusType::StatusEditorOnly)]);
m_gui->m_statusComboBox->setCurrentIndex(StatusTypeToIndex(StatusType::StatusEditorOnly));
m_gui->m_statusComboBox->setHeaderOverride(m_itemNames[static_cast<int>(StatusTypeToIndex(StatusType::StatusEditorOnly))]);
m_gui->m_statusComboBox->setCurrentIndex(static_cast<int>(StatusTypeToIndex(StatusType::StatusEditorOnly)));
m_comboItems[StatusTypeToIndex(StatusType::StatusEditorOnly)]->setCheckState(Qt::Checked);
}
else // Some marked active, some not
Code/Framework/AzToolsFramework/Tests/Prefab/Benchmark/PrefabBenchmarkFixture.cpp
+2 -2
View File
@@ -110,8 +110,8 @@ namespace Benchmark
void BM_Prefab::SetUpMockValidatorForReadPrefab()
{
int pathCount = m_paths.size();
for (int number = 0; number < pathCount; ++number)
const size_t pathCount = m_paths.size();
for (size_t number = 0; number < pathCount; ++number)
{
m_mockIOActionValidator->ReadPrefabDom(
m_paths[number], UnitTest::PrefabTestDomUtils::CreatePrefabDom());
Code/Framework/AzToolsFramework/Tests/Prefab/PrefabInstanceToTemplatePropagatorTests.cpp
+3 -1
View File
@@ -245,7 +245,9 @@ namespace UnitTest
m_instanceToTemplateInterface->GenerateDomForInstance(instanceDomBeforeUpdate, *firstInstance);
//remove instance from instance
firstInstance->DetachNestedInstance(addedAlias);
AZStd::unique_ptr<Instance> detachedInstance = firstInstance->DetachNestedInstance(addedAlias);
ASSERT_TRUE(detachedInstance != nullptr);
m_prefabSystemComponent->RemoveLink(detachedInstance->GetLinkId());
//create document with after change snapshot
PrefabDom instanceDomAfterUpdate;
Code/Framework/AzToolsFramework/Tests/Prefab/PrefabTestDomUtils.h
+2 -2
View File
@@ -38,7 +38,7 @@ namespace UnitTest
const EntityAlias& entityAlias)
{
return GetPrefabDomEntitiesPath()
.Append(entityAlias.c_str(), entityAlias.length());
.Append(entityAlias.c_str(), static_cast<rapidjson::SizeType>(entityAlias.length()));
};
inline PrefabDomPath GetPrefabDomEntityNamePath(
@@ -62,7 +62,7 @@ namespace UnitTest
inline PrefabDomPath GetPrefabDomInstancePath(
const InstanceAlias& instanceAlias)
{
return GetPrefabDomInstancesPath().Append(instanceAlias.c_str(), instanceAlias.length());
return GetPrefabDomInstancesPath().Append(instanceAlias.c_str(), static_cast<rapidjson::SizeType>(instanceAlias.length()));
};
inline PrefabDomPath GetPrefabDomInstancePath(
Code/Framework/AzToolsFramework/Tests/Prefab/PrefabUpdateInstancesTests.cpp
+1
View File
@@ -309,6 +309,7 @@ namespace UnitTest
// and use the updated enclosing Instance to update the PrefabDom of Template.
AZStd::unique_ptr<Instance> detachedInstance = newEnclosingInstance->DetachNestedInstance(nestedInstanceAliases.front());
ASSERT_TRUE(detachedInstance);
m_prefabSystemComponent->RemoveLink(detachedInstance->GetLinkId());
PrefabDom updatedTemplateDom;
ASSERT_TRUE(PrefabDomUtils::StoreInstanceInPrefabDom(*newEnclosingInstance, updatedTemplateDom));
Code/Framework/AzToolsFramework/Tests/Prefab/PrefabUpdateTemplateTests.cpp
+1
View File
@@ -274,6 +274,7 @@ namespace UnitTest
InstanceAlias aliasOfWheelInstanceToRetain = wheelInstanceAliasesUnderAxle.front();
AZStd::unique_ptr<Instance> detachedInstance = axleInstance->DetachNestedInstance(wheelInstanceAliasesUnderAxle.back());
ASSERT_TRUE(detachedInstance);
m_prefabSystemComponent->RemoveLink(detachedInstance->GetLinkId());
PrefabDom updatedAxleInstanceDom;
ASSERT_TRUE(PrefabDomUtils::StoreInstanceInPrefabDom(*axleInstance, updatedAxleInstanceDom));
m_prefabSystemComponent->UpdatePrefabTemplate(axleTemplateId, updatedAxleInstanceDom);
Code/Legacy/CryCommon/CryArray.h
+3 -3
View File
@@ -11,7 +11,7 @@
#define CRYINCLUDE_CRYCOMMON_CRYARRAY_H
#pragma once
#include "CryLegacyAllocator.h"
#include <CryLegacyAllocator.h>
#include <AzCore/std/string/string.h>
//---------------------------------------------------------------------------
@@ -664,7 +664,7 @@ namespace NArray
I capacity() const
{
I aligned_bytes = Align(size() * sizeof(T), sizeof(I));
I aligned_bytes = static_cast<I>(Align(size() * sizeof(T), sizeof(I)));
if (m_nSizeCap & nCAP_BIT)
{
// Capacity stored in word following data
@@ -682,7 +682,7 @@ namespace NArray
// Store size, and assert against overflow.
assert(s <= c);
m_nSizeCap = s;
I aligned_bytes = Align(s * sizeof(T), sizeof(I));
I aligned_bytes = static_cast<I>(Align(s * sizeof(T), sizeof(I)));
if (c * sizeof(T) >= aligned_bytes + sizeof(I))
{
// Has extra capacity, more than word-alignment
Code/Legacy/CryCommon/CryLegacyAllocator.h
-127
View File
@@ -10,8 +10,6 @@
#include "LegacyAllocator.h"
#include <AzCore/std/algorithm.h>
//-----------------------------------------------------------------------------
// CryModule allocation API
//-----------------------------------------------------------------------------
@@ -95,128 +93,3 @@ inline void* CryModuleReallocAlignImpl(void* prev, size_t size, size_t alignment
return ptr;
}
//-----------------------------------------------------------------------------
// CryCrt alloc API
//-----------------------------------------------------------------------------
inline size_t CryCrtSize(void* p)
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(p);
}
inline void* CryCrtMalloc(size_t size)
{
return CryModuleMalloc(size);
}
inline size_t CryCrtFree(void* p)
{
size_t size = CryCrtSize(p);
CryModuleFree(p);
return size;
};
//-----------------------------------------------------------------------------
// CrySystemCrt alloc API
//-----------------------------------------------------------------------------
inline size_t CrySystemCrtSize(void* p)
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(p);
}
inline void* CrySystemCrtMalloc(size_t size)
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().Allocate(size, 0, 0, "AZ::LegacyAllocator");
}
inline void* CrySystemCrtRealloc(void* p, size_t size)
{
// Use LegacyAllocator's special ReAllocate
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().ReAllocate(p, size, 0);
}
inline size_t CrySystemCrtFree(void* p)
{
size_t size = CrySystemCrtSize(p);
CryModuleFree(p);
return size;
}
inline size_t CrySystemCrtGetUsedSpace()
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().NumAllocatedBytes();
}
//-----------------------------------------------------------------------------
// CryMalloc API
//-----------------------------------------------------------------------------
inline void* CryMalloc(size_t size, size_t& allocated, size_t alignment)
{
if (!size)
{
allocated = 0;
return nullptr;
}
// The original implementation guaranteed 16 byte min alignment
alignment = AZStd::GetMax<size_t>(alignment, 16);
void* ptr = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().Allocate(size, alignment, 0, "CryMalloc", __FILE__, __LINE__);
allocated = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(ptr);
return ptr;
}
inline void* CryRealloc(void* memblock, size_t size, size_t& allocated, size_t& oldsize, size_t alignment)
{
oldsize = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(memblock);
void* ptr = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().ReAllocate(memblock, size, alignment);
allocated = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(ptr);
return ptr;
}
inline size_t CryFree(void* p, size_t /*alignment*/)
{
size_t size = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(p);
AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().DeAllocate(p, size);
return size;
}
inline size_t CryGetMemSize(void* memblock, size_t /*sourceSize*/)
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().AllocationSize(memblock);
}
inline int CryMemoryGetAllocatedSize()
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().NumAllocatedBytes();
}
//////////////////////////////////////////////////////////////////////////
inline int CryMemoryGetPoolSize()
{
return 0;
}
//////////////////////////////////////////////////////////////////////////
inline int CryStats([[maybe_unused]] char* buf)
{
return 0;
}
inline int CryGetUsedHeapSize()
{
return AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().NumAllocatedBytes();
}
inline int CryGetWastedHeapSize()
{
return 0;
}
inline void CryCleanup()
{
AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().GarbageCollect();
}
inline void CryResetStats(void)
{
}
Code/Legacy/CryCommon/CryName.h
+7 -7
View File
@@ -45,7 +45,7 @@ struct INameTable
const char* GetStr() { return (char*)(this + 1); }
void AddRef() { nRefCount++; /*InterlockedIncrement(&_header()->nRefCount);*/};
int Release() { return --nRefCount; };
int GetMemoryUsage() { return sizeof(SNameEntry) + strlen(GetStr()); }
int GetMemoryUsage() { return static_cast<int>(sizeof(SNameEntry) + strlen(GetStr())); }
int GetLength(){return nLength; }
};
@@ -102,14 +102,14 @@ public:
if (!pEntry)
{
// Create a new entry.
unsigned int nLen = strlen(str);
unsigned int allocLen = sizeof(SNameEntry) + (nLen + 1) * sizeof(char);
size_t nLen = strlen(str);
size_t allocLen = sizeof(SNameEntry) + (nLen + 1) * sizeof(char);
pEntry = (SNameEntry*)CryModuleMalloc(allocLen);
assert(pEntry != NULL);
pEntry->nTag = SNameEntry::TAG;
pEntry->nRefCount = 0;
pEntry->nLength = nLen;
pEntry->nAllocSize = allocLen;
pEntry->nLength = static_cast<int>(nLen);
pEntry->nAllocSize = static_cast<int>(allocLen);
// Copy string to the end of name entry.
char* pEntryStr = const_cast<char*>(pEntry->GetStr());
memcpy(pEntryStr, str, nLen + 1);
@@ -134,7 +134,7 @@ public:
int n = 0;
for (it = m_nameMap.begin(); it != m_nameMap.end(); it++)
{
nSize += strlen(it->first);
nSize += static_cast<int>(strlen(it->first));
nSize += it->second->GetMemoryUsage();
n++;
}
@@ -149,7 +149,7 @@ public:
}
virtual int GetNumberOfEntries()
{
return m_nameMap.size();
return static_cast<int>(m_nameMap.size());
}
// Log all names inside CryName table.
Code/Legacy/CryCommon/CryPodArray.h
+2 -2
View File
@@ -159,8 +159,8 @@ public:
return numElements != m_elements.size();
}
ILINE int Count() const { return m_elements.size(); }
ILINE unsigned int Size() const { return m_elements.size(); }
ILINE size_t Count() const { return m_elements.size(); }
ILINE size_t Size() const { return m_elements.size(); }
ILINE int IsEmpty() const { return m_elements.empty(); }
Code/Legacy/CryCommon/IIndexedMesh.h
+1 -1
View File
@@ -2094,7 +2094,7 @@ public:
{
if (activeStreams & (1U << i))
{
nMeshSize += ((i == VSF_GENERAL) ? sizeof(SVF_P3S_C4B_T2S) : cSizeStream[i]) * GetVertexCount();
nMeshSize += static_cast<uint32>(((i == VSF_GENERAL) ? sizeof(SVF_P3S_C4B_T2S) : cSizeStream[i]) * GetVertexCount());
nMeshSize += TARGET_DEFAULT_ALIGN - (nMeshSize & (TARGET_DEFAULT_ALIGN - 1));
}
}
Code/Legacy/CryCommon/IShader.h
+8 -8
View File
@@ -1425,9 +1425,9 @@ struct STexSamplerFX
SAFE_RELEASE(m_pITarget);
}
int Size()
size_t Size()
{
int nSize = sizeof(*this);
size_t nSize = sizeof(*this);
nSize += m_szName.capacity();
nSize += m_szTexture.capacity();
#if SHADER_REFLECT_TEXTURE_SLOTS
@@ -1804,9 +1804,9 @@ struct SEfResTexture
return m_Ext.m_pTexModifier;
}
int Size() const
size_t Size() const
{
int nSize = sizeof(SEfResTexture) - sizeof(STexSamplerRT) - sizeof(SEfResTextureExt);
size_t nSize = sizeof(SEfResTexture) - sizeof(STexSamplerRT) - sizeof(SEfResTextureExt);
nSize += m_Name.size();
nSize += m_Sampler.Size();
nSize += m_Ext.Size();
@@ -1899,9 +1899,9 @@ struct SBaseShaderResources
uint8 m_VoxelCoverage;
int Size() const
size_t Size() const
{
int nSize = sizeof(SBaseShaderResources) + m_ShaderParams.size() * sizeof(SShaderParam);
size_t nSize = sizeof(SBaseShaderResources) + m_ShaderParams.size() * sizeof(SShaderParam);
return nSize;
}
@@ -2031,9 +2031,9 @@ struct SInputShaderResources
TexturesResourcesMap m_TexturesResourcesMap; // a map of all textures resources used by the shader by name
SDeformInfo m_DeformInfo;
int Size() const
size_t Size() const
{
int nSize = SBaseShaderResources::Size();// -sizeof(SEfResTexture) * m_TexturesResourcesMap.size();
size_t nSize = SBaseShaderResources::Size();// -sizeof(SEfResTexture) * m_TexturesResourcesMap.size();
nSize += m_TexturePath.size();
nSize += sizeof(SDeformInfo);
Code/Legacy/CryCommon/VectorMap.h
+2 -4
View File
@@ -408,8 +408,7 @@ typename VectorMap<K, V, T, A>::key_compare VectorMap<K, V, T, A>::key_comp() co
template <typename K, typename V, typename T, typename A>
typename VectorMap<K, V, T, A>::iterator VectorMap<K, V, T, A>::lower_bound(const key_type& key)
{
int count = 0;
count = m_entries.size();
int count = static_cast<int>(m_entries.size());
iterator first = m_entries.begin();
iterator last = m_entries.end();
for (; 0 < count; )
@@ -432,8 +431,7 @@ typename VectorMap<K, V, T, A>::iterator VectorMap<K, V, T, A>::lower_bound(cons
template <typename K, typename V, typename T, typename A>
typename VectorMap<K, V, T, A>::const_iterator VectorMap<K, V, T, A>::lower_bound(const key_type& key) const
{
int count = 0;
count = m_entries.size();
int count = static_cast<int>(m_entries.size());
const_iterator first = m_entries.begin();
const_iterator last = m_entries.end();
for (; 0 < count; )
Code/Legacy/CryCommon/platform.h
-2
View File
@@ -475,8 +475,6 @@ ILINE DestinationType alias_cast(SourceType pPtr)
return conv_union.pDst;
}
#include "CryLegacyAllocator.h"
//////////////////////////////////////////////////////////////////////////
#ifndef DEPRECATED
#define DEPRECATED
Code/Legacy/CrySystem/ConsoleBatchFile.cpp
+1 -1
View File
@@ -112,7 +112,7 @@ bool CConsoleBatchFile::ExecuteConfigFile(const char* sFilename)
CryLog("%s \"%s\" found in %s ...", szLog, PathUtil::GetFile(filenameLog.c_str()), PathUtil::GetPath(filenameLog).c_str());
}
int nLen = file.GetLength();
size_t nLen = file.GetLength();
char* sAllText = new char [nLen + 16];
file.ReadRaw(sAllText, nLen);
sAllText[nLen] = '\0';
Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp
+1 -1
View File
@@ -161,7 +161,7 @@ struct SLevelNameAutoComplete
: public IConsoleArgumentAutoComplete
{
AZStd::vector<AZStd::string> levels;
virtual int GetCount() const { return levels.size(); };
virtual int GetCount() const { return static_cast<int>(levels.size()); };
virtual const char* GetValue(int nIndex) const { return levels[nIndex].c_str(); };
};
// definition and declaration must be separated for devirtualization
Code/Legacy/CrySystem/LocalizedStringManager.cpp
+8 -8
View File
@@ -479,7 +479,7 @@ void CLocalizedStringsManager::ParseFirstLine(IXmlTableReader* pXmlTableReader,
if (i == ELOCALIZED_COLUMN_SOUNDMOOD)
{
const char* pSoundMoodName = pFind + strlen(sLocalizedColumnNames[i]) + 1;
int nSoundMoodNameLength = sCellContent.length() - strlen(sLocalizedColumnNames[i]) - 1;
int nSoundMoodNameLength = static_cast<int>(sCellContent.length() - strlen(sLocalizedColumnNames[i]) - 1);
if (nSoundMoodNameLength > 0)
{
SoundMoodIndex[nCellIndex] = pSoundMoodName;
@@ -490,7 +490,7 @@ void CLocalizedStringsManager::ParseFirstLine(IXmlTableReader* pXmlTableReader,
if (i == ELOCALIZED_COLUMN_EVENTPARAMETER)
{
const char* pParameterName = pFind + strlen(sLocalizedColumnNames[i]) + 1;
int nParameterNameLength = sCellContent.length() - strlen(sLocalizedColumnNames[i]) - 1;
int nParameterNameLength = static_cast<int>(sCellContent.length() - strlen(sLocalizedColumnNames[i]) - 1);
if (nParameterNameLength > 0)
{
EventParameterIndex[nCellIndex] = pParameterName;
@@ -622,7 +622,7 @@ bool CLocalizedStringsManager::InitLocalizationData(
CRY_ASSERT(m_tagFileNames.size() < 255);
uint8 curNumTags = m_tagFileNames.size();
uint8 curNumTags = static_cast<uint8>(m_tagFileNames.size());
m_tagFileNames[sType].filenames = vEntries;
m_tagFileNames[sType].id = curNumTags + 1;
@@ -757,7 +757,7 @@ bool CLocalizedStringsManager::ReleaseLocalizationDataByTag(
bool bVecEntryErased = false;
//Then remove the entries in the storage vector
const uint32 numEntries = m_pLanguage->m_vLocalizedStrings.size();
const int32 numEntries = static_cast<int32>(m_pLanguage->m_vLocalizedStrings.size());
for (int32 i = numEntries - 1; i >= 0; i--)
{
SLocalizedStringEntry* entry = m_pLanguage->m_vLocalizedStrings[i];
@@ -1436,7 +1436,7 @@ bool CLocalizedStringsManager::DoLoadExcelXmlSpreadsheet(const char* sFileName,
// SoundMood Entries
{
pEntry->SoundMoods.resize(SoundMoodValues.size());
pEntry->SoundMoods.resize(static_cast<int>(SoundMoodValues.size()));
if (SoundMoodValues.size() > 0)
{
std::map<int, float>::const_iterator itEnd = SoundMoodValues.end();
@@ -1452,7 +1452,7 @@ bool CLocalizedStringsManager::DoLoadExcelXmlSpreadsheet(const char* sFileName,
// EventParameter Entries
{
pEntry->EventParameters.resize(EventParameterValues.size());
pEntry->EventParameters.resize(static_cast<int>(EventParameterValues.size()));
if (EventParameterValues.size() > 0)
{
std::map<int, float>::const_iterator itEnd = EventParameterValues.end();
@@ -2226,7 +2226,7 @@ int CLocalizedStringsManager::GetLocalizedStringCount()
{
return 0;
}
return m_pLanguage->m_vLocalizedStrings.size();
return static_cast<int>(m_pLanguage->m_vLocalizedStrings.size());
}
//////////////////////////////////////////////////////////////////////////
@@ -2339,7 +2339,7 @@ void InternalFormatStringMessage(AZStd::string& outString, const AZStd::string&
int maxArgUsed = 0;
int lastPos = 0;
int curPos = 0;
const int sourceLen = sString.length();
const int sourceLen = static_cast<int>(sString.length());
while (true)
{
auto foundPos = sString.find(token, curPos);
Code/Legacy/CrySystem/Log.cpp
+1 -1
View File
@@ -483,7 +483,7 @@ void CLog::LogV(const ELogType type, [[maybe_unused]]int flags, const char* szFo
break;
}
int bufferlen = sizeof(szBuffer) - prefixSize;
int bufferlen = static_cast<int>(sizeof(szBuffer) - prefixSize);
if (bufferlen > 0)
{
#if defined(AZ_RESTRICTED_PLATFORM)
Code/Legacy/CrySystem/SimpleStringPool.h
+2 -2
View File
@@ -216,8 +216,8 @@ public:
CryFatalError("Can't replace strings in an xml node that reuses strings");
}
int nStrLen1 = strlen(str1);
int nStrLen2 = strlen(str2);
int nStrLen1 = static_cast<int>(strlen(str1));
int nStrLen2 = static_cast<int>(strlen(str2));
// undo ptr1 add.
if (m_ptr != m_start)
Code/Legacy/CrySystem/SystemCFG.cpp
+3 -3
View File
@@ -287,7 +287,7 @@ public:
pos = 1;
for (;; )
{
pos = szValue.find_first_of("\\", pos);
pos = static_cast<int>(szValue.find_first_of("\\", pos));
if (pos == AZStd::string::npos)
{
@@ -302,7 +302,7 @@ public:
pos = 1;
for (;; )
{
pos = szValue.find_first_of("\"", pos);
pos = static_cast<int>(szValue.find_first_of("\"", pos));
if (pos == AZStd::string::npos)
{
@@ -416,7 +416,7 @@ bool CSystemConfiguration::ParseSystemConfig()
INDENT_LOG_DURING_SCOPE();
int nLen = file.GetLength();
int nLen = static_cast<int>(file.GetLength());
if (nLen == 0)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Couldn't get length for Config file %s", filename.c_str());
Code/Legacy/CrySystem/ViewSystem/View.cpp
+3 -3
View File
@@ -173,7 +173,7 @@ void CView::SetViewShakeEx(const SShakeParams& params)
return;
}
int shakes(m_shakes.size());
int shakes = static_cast<int>(m_shakes.size());
SShake* pSetShake(NULL);
for (int i = 0; i < shakes; ++i)
@@ -250,7 +250,7 @@ void CView::ProcessShaking(float frameTime)
m_viewParams.shakingRatio = 0;
m_viewParams.groundOnly = false;
int shakes(m_shakes.size());
int shakes = static_cast<int>(m_shakes.size());
for (int i = 0; i < shakes; ++i)
{
ProcessShake(&m_shakes[i], frameTime);
@@ -556,7 +556,7 @@ void CView::ProcessShakeNormal_DoShaking(SShake* pShake, float frameTime)
//------------------------------------------------------------------------
void CView::StopShake(int shakeID)
{
uint32 num = m_shakes.size();
uint32 num = static_cast<int>(m_shakes.size());
for (uint32 i = 0; i < num; ++i)
{
if (m_shakes[i].ID == shakeID && m_shakes[i].updating)
Code/Legacy/CrySystem/XConsole.cpp
+4 -4
View File
@@ -1283,7 +1283,7 @@ bool CXConsole::ProcessInput(const AzFramework::InputChannel& inputChannel)
{
if (isCtrlModifierActive)
{
m_nScrollLine = m_dqConsoleBuffer.size() - 1;
m_nScrollLine = static_cast<int>(m_dqConsoleBuffer.size() - 1);
}
else
{
@@ -1396,7 +1396,7 @@ bool CXConsole::GetLineNo(const int indwLineNo, char* outszBuffer, const int ind
//////////////////////////////////////////////////////////////////////////
int CXConsole::GetLineCount() const
{
return m_dqConsoleBuffer.size();
return static_cast<int>(m_dqConsoleBuffer.size());
}
//////////////////////////////////////////////////////////////////////////
@@ -2614,7 +2614,7 @@ void CXConsole::RemoveOutputPrintSink(IOutputPrintSink* inpSink)
{
assert(inpSink);
int nCount = m_OutputSinks.size();
int nCount = static_cast<int>(m_OutputSinks.size());
for (int i = 0; i < nCount; i++)
{
@@ -2900,7 +2900,7 @@ bool CXConsole::IsHashCalculated()
//////////////////////////////////////////////////////////////////////////
int CXConsole::GetNumCheatVars()
{
return m_randomCheckedVariables.size();
return static_cast<int>(m_randomCheckedVariables.size());
}
//////////////////////////////////////////////////////////////////////////
Code/Legacy/CrySystem/XConsole.h
+1 -1
View File
@@ -70,7 +70,7 @@ struct CConsoleCommandArgs
CConsoleCommandArgs(AZStd::string& line, std::vector<AZStd::string>& args)
: m_line(line)
, m_args(args) {};
virtual int GetArgCount() const { return m_args.size(); };
virtual int GetArgCount() const { return static_cast<int>(m_args.size()); };
// Get argument by index, nIndex must be in 0 <= nIndex < GetArgCount()
virtual const char* GetArg(int nIndex) const
{
Code/Legacy/CrySystem/XML/WriteXMLSource.cpp
+2 -1
View File
@@ -190,8 +190,9 @@ bool SaveArray(const IdTable& idTable, XmlNodeRef& definition, XmlNodeRef& data,
}
bool needIndex = false;
for (size_t i = 1; i <= numElems; i++)
for (size_t sizei = 1; sizei <= numElems; sizei++)
{
const int i = static_cast<int>(sizei);
if (!childSource->HaveElemAt(i))
{
needIndex = true;
Code/Legacy/CrySystem/XML/XMLBinaryWriter.cpp
+6 -6
View File
@@ -114,26 +114,26 @@ bool XMLBinary::CXMLBinaryWriter::WriteNode(IDataWriter* pFile, XmlNodeRef node,
nTheoreticalPosition += sizeof(header);
align(nTheoreticalPosition, nAlignment);
header.nNodeTablePosition = nTheoreticalPosition;
header.nNodeTablePosition = static_cast<uint32>(nTheoreticalPosition);
header.nNodeCount = int(m_nodes.size());
nTheoreticalPosition += header.nNodeCount * sizeof(Node);
align(nTheoreticalPosition, nAlignment);
header.nChildTablePosition = nTheoreticalPosition;
header.nChildTablePosition = static_cast<uint32>(nTheoreticalPosition);
header.nChildCount = int(m_childs.size());
nTheoreticalPosition += header.nChildCount * sizeof(NodeIndex);
align(nTheoreticalPosition, nAlignment);
header.nAttributeTablePosition = nTheoreticalPosition;
header.nAttributeTablePosition = static_cast<uint32>(nTheoreticalPosition);
header.nAttributeCount = int(m_attributes.size());
nTheoreticalPosition += header.nAttributeCount * sizeof(Attribute);
align(nTheoreticalPosition, nAlignment);
header.nStringDataPosition = nTheoreticalPosition;
header.nStringDataPosition = static_cast<uint32>(nTheoreticalPosition);
header.nStringDataSize = m_nStringDataSize;
nTheoreticalPosition += header.nStringDataSize;
header.nXMLSize = nTheoreticalPosition;
header.nXMLSize = static_cast<uint32>(nTheoreticalPosition);
// Swap endianness of the data structures
if (bNeedSwapEndian)
@@ -328,7 +328,7 @@ int XMLBinary::CXMLBinaryWriter::AddString(const XmlString& sString)
// We don't have such string yet, so we should add it to the tables.
m_strings.push_back(sString);
itStringEntry = m_stringMap.insert(StringMap::value_type(sString, m_nStringDataSize)).first;
m_nStringDataSize += sString.length() + 1;
m_nStringDataSize += static_cast<uint>(sString.length() + 1);
}
// Return offset of the string in the string data buffer.

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