Legacy code cleanup - part 3 (#3903)

* Legacy cleanup - part 3

Not much is left that can be easily removed,
so I think this will be last cleanup before the legacy functionality is replaced.

Signed-off-by: nemerle <[email protected]>

* fix windows build, remove a few more things, re-add one file

Signed-off-by: nemerle <[email protected]>

* Remove legacy RenderBus + more cleanups

Signed-off-by: nemerle <[email protected]>

* Remove MaterialOwnerBus.h

Clean-up in Cry_Matrix34/33

Signed-off-by: nemerle <[email protected]>

Code/Editor/Controls/ConsoleSCB.cpp

@@ -26,9 +26,6 @@
 #include <AzQtComponents/Components/Widgets/ScrollBar.h>
 #include <AzQtComponents/Components/Widgets/SliderCombo.h>
 
-// CryCommon
-#include <CryCommon/SFunctor.h>
-
 // Editor
 #include "QtViewPaneManager.h"
 #include "Core/QtEditorApplication.h"
@@ -392,7 +389,7 @@ void CConsoleSCB::RegisterViewClass()
     opts.showInMenu = true;
     opts.builtInActionId = ID_VIEW_CONSOLEWINDOW;
     opts.shortcut = QKeySequence(Qt::Key_QuoteLeft);
-    
+
     AzToolsFramework::RegisterViewPane<CConsoleSCB>(LyViewPane::Console, LyViewPane::CategoryTools, opts);
 }
 
@@ -606,8 +603,7 @@ static CVarBlock* VarBlockFromConsoleVars()
 
         // Add our on change handler so we can update the CVariable created for
         // the matching ICVar that has been modified
-        SFunctor onChange;
-        onChange.Set(OnVariableUpdated, i, pCVar);
+        AZStd::function<void()> onChange = [row=i,pCVar=pCVar]() { OnVariableUpdated(row,pCVar); };
         pCVar->AddOnChangeFunctor(onChange);
 
         pVariable->SetDescription(pCVar->GetHelp());
@@ -929,7 +925,7 @@ QWidget* ConsoleVariableItemDelegate::createEditor(QWidget* parent, const QStyle
             return editor;
         }
     }
-    
+
     // If we get here, value being edited is a string, so use our styled line
     // edit widget
     AzQtComponents::StyledLineEdit* lineEdit = new AzQtComponents::StyledLineEdit(parent);

Code/Editor/CryEditDoc.cpp

@@ -1887,16 +1887,6 @@ void CCryEditDoc::SetDocumentReady(bool bReady)
     m_bDocumentReady = bReady;
 }
 
-void CCryEditDoc::GetMemoryUsage(ICrySizer* pSizer) const
-{
-    {
-        SIZER_COMPONENT_NAME(pSizer, "UndoManager(estimate)");
-        GetIEditor()->GetUndoManager()->GetMemoryUsage(pSizer);
-    }
-
-    pSizer->Add(*this);
-}
-
 void CCryEditDoc::RegisterConsoleVariables()
 {
     doc_validate_surface_types = gEnv->pConsole->GetCVar("doc_validate_surface_types");

Code/Editor/CryEditDoc.h

@@ -129,8 +129,6 @@ public: // Create from serialization only
     void RegisterListener(IDocListener* listener);
     void UnregisterListener(IDocListener* listener);
 
-    void GetMemoryUsage(ICrySizer* pSizer) const;
-
     static bool IsBackupOrTempLevelSubdirectory(const QString& folderName);
 protected:
 

Code/Editor/ErrorReport.cpp

@@ -249,60 +249,6 @@ void CErrorReport::SetImmediateMode(bool bEnable)
     }
 }
 
-//////////////////////////////////////////////////////////////////////////
-void CErrorReport::Report(SValidatorRecord& record)
-{
-    if ((record.flags & VALIDATOR_FLAG_IGNORE_IN_EDITOR))
-    {
-        return;
-    }
-
-    CErrorRecord err;
-    if (record.text)
-    {
-        err.error = record.text;
-    }
-    if (record.description)
-    {
-        err.description = record.description;
-    }
-    if (record.file)
-    {
-        err.file = record.file;
-    }
-    else
-    {
-        err.file = m_currentFilename;
-    }
-    err.severity = (CErrorRecord::ESeverity)record.severity;
-
-    err.assetScope = record.assetScope;
-
-    err.flags = 0;
-    if (record.flags & VALIDATOR_FLAG_FILE)
-    {
-        err.flags |= CErrorRecord::FLAG_NOFILE;
-    }
-    if (record.flags & VALIDATOR_FLAG_TEXTURE)
-    {
-        err.flags |= CErrorRecord::FLAG_TEXTURE;
-    }
-    if (record.flags & VALIDATOR_FLAG_SCRIPT)
-    {
-        err.flags |= CErrorRecord::FLAG_SCRIPT;
-    }
-    if (record.flags & VALIDATOR_FLAG_AI)
-    {
-        err.flags |= CErrorRecord::FLAG_AI;
-    }
-
-    err.module = record.module;
-    err.pObject = m_pObject;
-    err.pItem = m_pItem;
-
-    ReportError(err);
-}
-
 //////////////////////////////////////////////////////////////////////////
 void CErrorReport::SetCurrentValidatorObject(CBaseObject* pObject)
 {

Code/Editor/ErrorReport.h

@@ -121,11 +121,6 @@ public:
     //! Assign current filename.
     void SetCurrentFile(const QString& file);
 
-    //////////////////////////////////////////////////////////////////////////
-    // Implement IValidator interface.
-    //////////////////////////////////////////////////////////////////////////
-    virtual void Report(SValidatorRecord& record);
-
 private:
     //! Array of all error records added to report.
     std::vector<CErrorRecord> m_errors;

Code/Editor/GameEngine.cpp

@@ -176,11 +176,6 @@ struct SSystemUserCallback
         return CryMessageBox(text, caption, uType);
     }
 
-    void GetMemoryUsage(ICrySizer* pSizer) override
-    {
-        GetIEditor()->GetMemoryUsage(pSizer);
-    }
-
     void OnSplashScreenDone()
     {
         m_pLogo = nullptr;

Code/Editor/GameExporter.h

@@ -5,10 +5,6 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
-
-#ifndef CRYINCLUDE_EDITOR_GAMEEXPORTER_H
-#define CRYINCLUDE_EDITOR_GAMEEXPORTER_H
 #pragma once
 
 #include "Util/PakFile.h"
@@ -62,7 +58,7 @@ public:
     // In auto exporting mode, highest possible settings will be chosen and no UI dialogs will be shown.
     void SetAutoExportMode(bool bAuto) { m_bAutoExportMode = bAuto; }
 
-    bool Export(unsigned int flags = 0, EEndian eExportEndian = GetPlatformEndian(), const char* subdirectory = 0);
+    bool Export(unsigned int flags = 0, EEndian eExportEndian = eEndianness_Little, const char* subdirectory = 0);
 
     static CGameExporter* GetCurrentExporter() { return m_pCurrentExporter; }
 
@@ -116,5 +112,3 @@ void SetupTerrainInfo(const size_t octreeCompiledDataSize, Func&& setupTerrainFn
         setupTerrainFn(octreeCompiledDataSize);
     }
 }
-
-#endif // CRYINCLUDE_EDITOR_GAMEEXPORTER_H

Code/Editor/IEditor.h

@@ -701,7 +701,6 @@ struct IEditor
 
     virtual CUIEnumsDatabase* GetUIEnumsDatabase() = 0;
     virtual void AddUIEnums() = 0;
-    virtual void GetMemoryUsage(ICrySizer* pSizer) = 0;
     virtual void ReduceMemory() = 0;
 
     //! Export manager for exporting objects and a terrain from the game to DCC tools

Code/Editor/IEditorImpl.cpp

@@ -1506,18 +1506,6 @@ void CEditorImpl::ShowStatusText(bool bEnable)
     m_bShowStatusText = bEnable;
 }
 
-void CEditorImpl::GetMemoryUsage(ICrySizer* pSizer)
-{
-    SIZER_COMPONENT_NAME(pSizer, "Editor");
-
-    if (GetDocument())
-    {
-        SIZER_COMPONENT_NAME(pSizer, "Document");
-
-        GetDocument()->GetMemoryUsage(pSizer);
-    }
-}
-
 void CEditorImpl::ReduceMemory()
 {
     GetIEditor()->GetUndoManager()->ClearRedoStack();

Code/Editor/IEditorImpl.h

@@ -280,7 +280,6 @@ public:
     void SetMatEditMode(bool bIsMatEditMode);
     CUIEnumsDatabase* GetUIEnumsDatabase() { return m_pUIEnumsDatabase; };
     void AddUIEnums();
-    void GetMemoryUsage(ICrySizer* pSizer);
     void ReduceMemory();
     // Get Export manager
     IExportManager* GetExportManager();

Code/Editor/IconManager.cpp

@@ -64,10 +64,7 @@ void CIconManager::Reset()
     int i;
     for (i = 0; i < sizeof(m_objects) / sizeof(m_objects[0]); i++)
     {
-        if (m_objects[i])
-        {
-            m_objects[i]->Release();
-        }
+        delete m_objects[i];
         m_objects[i] = nullptr;
     }
     for (i = 0; i < eIcon_COUNT; i++)

Code/Editor/Include/Command.h

@@ -24,16 +24,15 @@ inline AZStd::string ToString(const QString& s)
 
 class CCommand
 {
-    static inline bool FromString(int32 &val, const char* s) {
-        if(!s)
+    static inline bool FromString(int32& val, const char* s)
+    {
+        if (!s)
         {
             return false;
         }
-        val = (int)strtol(s, nullptr, 10);
-        if(val==0 && errno!=0) {
-            return false;
-        }
-        return true;
+        val = static_cast<int>(strtol(s, nullptr, 10));
+        const bool parsing_error = val == 0 && errno != 0;
+        return !parsing_error;
     }
 public:
     CCommand(

Code/Editor/Include/IEditorMaterial.h

@@ -15,6 +15,6 @@ struct IEditorMaterial
     : public CBaseLibraryItem
 {
     virtual int GetFlags() const = 0;
-    virtual _smart_ptr<IMaterial> GetMatInfo(bool bUseExistingEngineMaterial = false) = 0;
+    virtual IMaterial* GetMatInfo(bool bUseExistingEngineMaterial = false) = 0;
     virtual void DisableHighlightForFrame() = 0;
 };

Code/Editor/Include/IEditorMaterialManager.h

@@ -19,7 +19,7 @@
 
 struct IEditorMaterialManager
 {
-    virtual void GotoMaterial(_smart_ptr<IMaterial> pMaterial) = 0;
+    virtual void GotoMaterial(IMaterial* pMaterial) = 0;
 };
 
 #endif // CRYINCLUDE_EDITOR_MATERIAL_MATERIALMANAGER_H

Code/Editor/Include/IErrorReport.h

@@ -9,23 +9,18 @@
 
 
 // Description : Class that collects error reports to present them later.
-
-#ifndef CRYINCLUDE_EDITOR_INTERFACE_ERRORREPORT_H
-#define CRYINCLUDE_EDITOR_INTERFACE_ERRORREPORT_H
 #pragma once
 
-#include <IValidator.h>
-
 // forward declarations.
 class CParticleItem;
 class CBaseObject;
 class CBaseLibraryItem;
 class CErrorRecord;
+class QString;
 
 /*! Error report manages collection of errors occurred during map analyzes or level load.
  */
 struct IErrorReport
-    : public IValidator
 {
     virtual ~IErrorReport(){}
 
@@ -62,12 +57,4 @@ struct IErrorReport
 
     //! Assign current filename.
     virtual void SetCurrentFile(const QString& file) = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Implement IValidator interface.
-    //////////////////////////////////////////////////////////////////////////
-    virtual void Report(SValidatorRecord& record) = 0;
 };
-
-
-#endif // CRYINCLUDE_EDITOR_ERRORREPORT_H

Code/Editor/Include/IObjectManager.h

@@ -89,7 +89,6 @@ public:
     //! Get array of objects, managed by manager (not contain sub objects of groups).
     //! @param layer if 0 get objects for all layers, or layer to get objects from.
     virtual void GetObjects(CBaseObjectsArray& objects) const = 0;
-    //virtual void GetObjects(DynArray<CBaseObject*>& objects) const = 0;
 
     //! Get array of objects that pass the filter.
     //! @param filter The filter functor, return true if you want to get the certain obj, return false if want to skip it.

Code/Editor/Lib/Tests/IEditorMock.h

@@ -170,7 +170,6 @@ public:
     MOCK_METHOD0(IsSourceControlConnected, bool());
     MOCK_METHOD0(GetUIEnumsDatabase, CUIEnumsDatabase* ());
     MOCK_METHOD0(AddUIEnums, void());
-    MOCK_METHOD1(GetMemoryUsage, void(ICrySizer* ));
     MOCK_METHOD0(ReduceMemory, void());
     MOCK_METHOD0(GetExportManager, IExportManager* ());
     MOCK_METHOD2(SetEditorConfigSpec, void(ESystemConfigSpec , ESystemConfigPlatform ));

Code/Editor/Objects/BaseObject.cpp

@@ -2735,7 +2735,7 @@ bool CBaseObject::IntersectRayMesh(const Vec3& raySrc, const Vec3& rayDir, SRayH
         return false;
     }
 
-    Matrix34A worldTM;
+    Matrix34 worldTM;
     IStatObj* pStatObj = pRenderNode->GetEntityStatObj(0, 0, &worldTM);
     if (!pStatObj)
     {
@@ -2743,7 +2743,7 @@ bool CBaseObject::IntersectRayMesh(const Vec3& raySrc, const Vec3& rayDir, SRayH
     }
 
     // transform decal into object space
-    Matrix34A worldTM_Inverted = worldTM.GetInverted();
+    Matrix34 worldTM_Inverted = worldTM.GetInverted();
     Matrix33 worldRot(worldTM_Inverted);
     worldRot.Transpose();
     // put hit direction into the object space

Code/Editor/Objects/ObjectManager.cpp

@@ -759,17 +759,6 @@ void CObjectManager::GetObjects(CBaseObjectsArray& objects) const
     }
 }
 
-//void CObjectManager::GetObjects(DynArray<CBaseObject*>& objects) const
-//{
-//    CBaseObjectsArray objectArray;
-//    GetObjects(objectArray);
-//    objects.clear();
-//    for (size_t i = 0, iCount(objectArray.size()); i < iCount; ++i)
-//    {
-//        objects.push_back(objectArray[i]);
-//    }
-//}
-
 void CObjectManager::GetObjects(CBaseObjectsArray& objects, BaseObjectFilterFunctor const& filter) const
 {
     objects.clear();

Code/Editor/Objects/ObjectManager.h

@@ -122,7 +122,6 @@ public:
     //! Get array of objects, managed by manager (not contain sub objects of groups).
     //! @param layer if 0 get objects for all layers, or layer to get objects from.
     void GetObjects(CBaseObjectsArray& objects) const;
-    //void GetObjects(DynArray<CBaseObject*>& objects) const;
 
     //! Get array of objects that pass the filter.
     //! @param filter The filter functor, return true if you want to get the certain obj, return false if want to skip it.

Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp

@@ -37,7 +37,6 @@
 #include <AzToolsFramework/ToolsComponents/EditorEntityIconComponentBus.h>
 #include <AzToolsFramework/Undo/UndoCacheInterface.h>
 #include <LmbrCentral/Rendering/RenderNodeBus.h>
-#include <LmbrCentral/Rendering/MaterialOwnerBus.h>
 
 #include <IDisplayViewport.h>
 #include <CryCommon/Cry_GeoIntersect.h>

Code/Editor/Undo/Undo.cpp

@@ -62,17 +62,6 @@ public:
         }
     }
 
-    // to get memory statistics
-    void GetMemoryUsage(ICrySizer* pSizer)
-    {
-        for (int i = 0; i < m_undoSteps.size(); i++)
-        {
-            m_undoSteps[i]->GetMemoryUsage(pSizer);
-        }
-
-        pSizer->Add(*this);
-    }
-
 private:
     //! Undo steps included in this step.
     std::vector<CUndoStep*> m_undoSteps;
@@ -746,31 +735,6 @@ int CUndoManager::GetMaxUndoStep() const
     return GetIEditor()->GetEditorSettings()->undoLevels;
 }
 
-void CUndoManager::GetMemoryUsage(ICrySizer* pSizer)
-{
-    if (m_currentUndo)
-    {
-        m_currentUndo->GetMemoryUsage(pSizer);
-    }
-
-    if (m_superUndo)
-    {
-        m_superUndo->GetMemoryUsage(pSizer);
-    }
-
-    for (std::list<CUndoStep*>::const_iterator it = m_undoStack.begin(); it != m_undoStack.end(); it++)
-    {
-        (*it)->GetMemoryUsage(pSizer);
-    }
-
-    for (std::list<CUndoStep*>::const_iterator it = m_redoStack.begin(); it != m_redoStack.end(); it++)
-    {
-        (*it)->GetMemoryUsage(pSizer);
-    }
-
-    pSizer->Add(*this);
-}
-
 void CUndoManager::AddListener(IUndoManagerListener* pListener)
 {
     stl::push_back_unique(m_listeners, pListener);

Code/Editor/Undo/Undo.h

@@ -12,9 +12,9 @@
 #pragma once
 
 #include "IUndoManagerListener.h"
-#include "CrySizer.h"                           // ICrySizer
 #include "IUndoObject.h"
 #include <AzCore/Asset/AssetManager.h>
+#include <CryCommon/StlUtils.h>
 
 struct IUndoObject;
 class CSuperUndoStep;
@@ -79,20 +79,6 @@ public:
         }
     }
 
-    // to get memory statistics
-    void GetMemoryUsage(ICrySizer* pSizer)
-    {
-        size_t nThisSize = sizeof(*this);
-
-        for (int i = 0; i < m_undoObjects.size(); i++)
-        {
-            nThisSize += m_undoObjects[i]->GetSize();
-        }
-
-        pSizer->Add(m_name);
-        pSizer->Add(this, nThisSize);
-    }
-
     // get undo object at index i
     IUndoObject* GetUndoObject(int i = 0)
     {
@@ -241,9 +227,6 @@ public:
     void ClearUndoStack(int num);
     void ClearRedoStack(int num);
 
-    // to get memory statistics
-    void GetMemoryUsage(ICrySizer* pSizer);
-
     void AddListener(IUndoManagerListener* pListener);
     void RemoveListener(IUndoManagerListener* pListener);
 

Code/Editor/Util/EditorUtils.h

@@ -20,9 +20,6 @@
 #include <Cry_Color.h>
 #include <CryCommon/ISystem.h>
 
-//! Typedef for quaternion.
-//typedef CryQuat Quat;
-
 #include <QColor>
 #include <QDataStream>
 #include <QGuiApplication>

Code/Editor/Util/KDTree.h

@@ -37,7 +37,7 @@ public:
     struct SStatObj
     {
         Matrix34 tm;
-        _smart_ptr<IStatObj> pStatObj;
+        IStatObj* pStatObj;
     };
 
 private:

Code/Legacy/CryCommon/BaseTypes.h

@@ -6,9 +6,6 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_BASETYPES_H
-#define CRYINCLUDE_CRYCOMMON_BASETYPES_H
 #pragma once
 
 static_assert(sizeof(char) == 1);
@@ -78,5 +75,3 @@ typedef float  f32;
 typedef double f64;
 static_assert(sizeof(f32) == 4);
 static_assert(sizeof(f64) == 8);
-
-#endif // CRYINCLUDE_CRYCOMMON_BASETYPES_H

Code/Legacy/CryCommon/BitFiddling.h

@@ -1,543 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : various integer bit fiddling hacks
-
-
-#pragma once
-
-#include <AzCore/Casting/numeric_cast.h>
-
-// Section dictionary
-#if defined(AZ_RESTRICTED_PLATFORM)
-#define BITFIDDLING_H_SECTION_TRAITS 1
-#define BITFIDDLING_H_SECTION_INTEGERLOG2 2
-#endif
-
-// Traits
-#if defined(AZ_RESTRICTED_PLATFORM)
-    #define AZ_RESTRICTED_SECTION BITFIDDLING_H_SECTION_TRAITS
-    #include AZ_RESTRICTED_FILE(BitFiddling_h)
-#elif defined(LINUX) || defined(APPLE)
-#define BITFIDDLING_H_TRAIT_HAS_COUNT_LEADING_ZEROS 1
-#endif
-
-#if BITFIDDLING_H_TRAIT_HAS_COUNT_LEADING_ZEROS
-#define countLeadingZeros32(x)              __builtin_clz(x)
-#else       // Windows implementation
-ILINE uint32 countLeadingZeros32(uint32 x)
-{
-    DWORD result = 32 ^ 31; // assumes result is unmodified if _BitScanReverse returns 0
-    _BitScanReverse(&result, x);
-    result ^= 31; // needed because the index is from LSB (whereas all other implementations are from MSB)
-    return result;
-}
-#endif
-
-inline uint32 circularShift(uint32 nbits, uint32 i)
-{
-    return (i << nbits) | (i >> (32 - nbits));
-}
-
-template <typename T>
-inline size_t countTrailingZeroes(T v)
-{
-    size_t n = 0;
-
-    v = ~v & (v - 1);
-    while (v)
-    {
-        ++n;
-        v >>= 1;
-    }
-
-    return n;
-}
-
-// this function returns the integer logarithm of various numbers without branching
-#define IL2VAL(mask, shift)         \
-    c |= ((x & mask) != 0) * shift; \
-    x >>= ((x & mask) != 0) * shift
-
-template <typename TInteger>
-inline bool IsPowerOfTwo(TInteger x)
-{
-    return (x & (x - 1)) == 0;
-}
-
-inline uint32 NextPower2(uint32 n)
-{
-    n--;
-    n |= n >> 1;
-    n |= n >> 2;
-    n |= n >> 4;
-    n |= n >> 8;
-    n |= n >> 16;
-    n++;
-    return n;
-}
-
-inline uint8 IntegerLog2(uint8 x)
-{
-    uint8 c = 0;
-    IL2VAL(0xf0, 4);
-    IL2VAL(0xc, 2);
-    IL2VAL(0x2, 1);
-    return c;
-}
-inline uint16 IntegerLog2(uint16 x)
-{
-    uint16 c = 0;
-    IL2VAL(0xff00, 8);
-    IL2VAL(0xf0, 4);
-    IL2VAL(0xc, 2);
-    IL2VAL(0x2, 1);
-    return c;
-}
-
-inline uint32 IntegerLog2(uint32 x)
-{
-    return 31 - countLeadingZeros32(x);
-}
-
-inline uint64 IntegerLog2(uint64 x)
-{
-    uint64 c = 0;
-    IL2VAL(0xffffffff00000000ull, 32);
-    IL2VAL(0xffff0000u, 16);
-    IL2VAL(0xff00, 8);
-    IL2VAL(0xf0, 4);
-    IL2VAL(0xc, 2);
-    IL2VAL(0x2, 1);
-    return c;
-}
-
-#if defined(APPLE) || defined(LINUX)
-inline unsigned long int IntegerLog2(unsigned long int x)
-{
-    #if defined(PLATFORM_64BIT)
-    return IntegerLog2((uint64)x);
-  #else
-    return IntegerLog2((uint32)x);
-  #endif
-}
-#endif
-#undef IL2VAL
-
-#if defined(AZ_RESTRICTED_PLATFORM)
-    #define AZ_RESTRICTED_SECTION BITFIDDLING_H_SECTION_INTEGERLOG2
-    #include AZ_RESTRICTED_FILE(BitFiddling_h)
-#endif
-
-template <typename TInteger>
-inline TInteger IntegerLog2_RoundUp(TInteger x)
-{
-    return 1 + IntegerLog2(x - 1);
-}
-
-static ILINE uint8 BitIndex(uint8 v)
-{
-    uint32 vv = v;
-    return aznumeric_caster(31 - countLeadingZeros32(vv));
-}
-
-static ILINE uint8 BitIndex(uint16 v)
-{
-    uint32 vv = v;
-    return aznumeric_caster(31 - countLeadingZeros32(vv));
-}
-
-static ILINE uint8 BitIndex(uint32 v)
-{
-    return aznumeric_caster(31 - countLeadingZeros32(v));
-}
-
-static ILINE uint8 CountBits(uint8 v)
-{
-    uint8 c = v;
-    c = ((c >> 1) & 0x55) + (c & 0x55);
-    c = ((c >> 2) & 0x33) + (c & 0x33);
-    c = ((c >> 4) & 0x0f) + (c & 0x0f);
-    return c;
-}
-
-static ILINE uint8 CountBits(uint16 v)
-{
-    return CountBits((uint8)(v  & 0xff)) +
-           CountBits((uint8)((v >> 8) & 0xff));
-}
-
-static ILINE uint8 CountBits(uint32 v)
-{
-    return CountBits((uint8)(v          & 0xff)) +
-           CountBits((uint8)((v >> 8) & 0xff)) +
-           CountBits((uint8)((v >> 16) & 0xff)) +
-           CountBits((uint8)((v >> 24) & 0xff));
-}
-
-// Branchless version of return v < 0 ? alt : v;
-ILINE int32 Isel32(int32 v, int32 alt)
-{
-    return ((static_cast<int32>(v) >> 31) & alt) | ((static_cast<int32>(~v) >> 31) & v);
-}
-
-// Character-to-bitfield mapping
-
-inline uint32 AlphaBit(char c)
-{
-    return c >= 'a' && c <= 'z' ? 1 << (c - 'z' + 31) : 0;
-}
-
-inline uint64 AlphaBit64(char c)
-{
-    return (c >= 'a' && c <= 'z' ? 1U << (c - 'z' + 31) : 0) |
-           (c >= 'A' && c <= 'Z' ? 1LL << (c - 'Z' + 63) : 0);
-}
-
-inline uint32 AlphaBits(uint32 wc)
-{
-    // Handle wide multi-char constants, can be evaluated at compile-time.
-    return AlphaBit((char)wc)
-           | AlphaBit((char)(wc >> 8))
-           | AlphaBit((char)(wc >> 16))
-           | AlphaBit((char)(wc >> 24));
-}
-
-inline uint32 AlphaBits(const char* s)
-{
-    // Handle string of any length.
-    uint32 n = 0;
-    while (*s)
-    {
-        n |= AlphaBit(*s++);
-    }
-    return n;
-}
-
-inline uint64 AlphaBits64(const char* s)
-{
-    // Handle string of any length.
-    uint64 n = 0;
-    while (*s)
-    {
-        n |= AlphaBit64(*s++);
-    }
-    return n;
-}
-
-// s should point to a buffer at least 65 chars long
-inline void BitsAlpha64(uint64 n, char* s)
-{
-    for (int i = 0; n != 0; n >>= 1, i++)
-    {
-        if (n & 1)
-        {
-            *s++ = i < 32 ? static_cast<char>(i + 'z' - 31) : static_cast<char>(i + 'Z' - 63);
-        }
-    }
-    *s++ = '\0';
-}
-
-
-// if hardware doesn't support 3Dc we can convert to DXT5 (different channels are used)
-// with almost the same quality but the same memory requirements
-inline void ConvertBlock3DcToDXT5(uint8 pDstBlock[16], const uint8 pSrcBlock[16])
-{
-    assert(pDstBlock != pSrcBlock);       // does not work in place
-
-    // 4x4 block requires 8 bytes in DXT5 or 3DC
-
-    // DXT5:  8 bit alpha0, 8 bit alpha1, 16*3 bit alpha lerp
-    //        16bit col0, 16 bit col1 (R5G6B5 low byte then high byte), 16*2 bit color lerp
-
-    //  3DC:  8 bit x0, 8 bit x1, 16*3 bit x lerp
-    //        8 bit y0, 8 bit y1, 16*3 bit y lerp
-
-    for (uint32 dwK = 0; dwK < 8; ++dwK)
-    {
-        pDstBlock[dwK] = pSrcBlock[dwK];
-    }
-    for (uint32 dwK = 8; dwK < 16; ++dwK)
-    {
-        pDstBlock[dwK] = 0;
-    }
-
-    // 6 bit green channel (highest bits)
-    // by using all 3 channels with a slight offset we can get more precision but then a dot product would be needed in PS
-    // because of bilinear filter we cannot just distribute bits to get perfect result
-    uint16 colDst0 = (((uint16)pSrcBlock[8] + 2) >> 2) << 5;
-    uint16 colDst1 = (((uint16)pSrcBlock[9] + 2) >> 2) << 5;
-
-    bool bFlip = colDst0 <= colDst1;
-
-    if (bFlip)
-    {
-        uint16 help = colDst0;
-        colDst0 = colDst1;
-        colDst1 = help;
-    }
-
-    bool bEqual = colDst0 == colDst1;
-
-    // distribute bytes by hand to not have problems with endianess
-    pDstBlock[8 + 0] = (uint8)colDst0;
-    pDstBlock[8 + 1] = (uint8)(colDst0 >> 8);
-    pDstBlock[8 + 2] = (uint8)colDst1;
-    pDstBlock[8 + 3] = (uint8)(colDst1 >> 8);
-
-    uint16* pSrcBlock16 = (uint16*)(pSrcBlock + 10);
-    uint16* pDstBlock16 = (uint16*)(pDstBlock + 12);
-
-    // distribute 16 3 bit values to 16 2 bit values (loosing LSB)
-    for (uint32 dwK = 0; dwK < 16; ++dwK)
-    {
-        uint32 dwBit0 = dwK * 3 + 0;
-        uint32 dwBit1 = dwK * 3 + 1;
-        uint32 dwBit2 = dwK * 3 + 2;
-
-        uint8 hexDataIn = (((pSrcBlock16[(dwBit2 >> 4)] >> (dwBit2 & 0xf)) & 1) << 2)         // get HSB
-            | (((pSrcBlock16[(dwBit1 >> 4)] >> (dwBit1 & 0xf)) & 1) << 1)
-            | ((pSrcBlock16[(dwBit0 >> 4)] >> (dwBit0 & 0xf)) & 1);                 // get LSB
-
-        uint8 hexDataOut = 0;
-
-        switch (hexDataIn)
-        {
-        case 0:
-            hexDataOut = 0;
-            break;                          // color 0
-        case 1:
-            hexDataOut = 1;
-            break;                          // color 1
-
-        case 2:
-            hexDataOut = 0;
-            break;                          // mostly color 0
-        case 3:
-            hexDataOut = 2;
-            break;
-        case 4:
-            hexDataOut = 2;
-            break;
-        case 5:
-            hexDataOut = 3;
-            break;
-        case 6:
-            hexDataOut = 3;
-            break;
-        case 7:
-            hexDataOut = 1;
-            break;                          // mostly color 1
-
-        default:
-            assert(0);
-        }
-
-        if (bFlip)
-        {
-            if (hexDataOut < 2)
-            {
-                hexDataOut = 1 - hexDataOut;        // 0<->1
-            }
-            else
-            {
-                hexDataOut = 5 - hexDataOut;  // 2<->3
-            }
-        }
-
-        if (bEqual)
-        {
-            if (hexDataOut == 3)
-            {
-                hexDataOut = 1;
-            }
-        }
-
-        pDstBlock16[(dwK >> 3)] |= (hexDataOut << ((dwK & 0x7) << 1));
-    }
-}
-
-
-
-
-// is a bit on in a new bit field, but off in an old bit field
-static ILINE bool TurnedOnBit(unsigned bit, unsigned oldBits, unsigned newBits)
-{
-    return (newBits & bit) != 0 && (oldBits & bit) == 0;
-}
-
-
-
-
-
-
-
-inline uint32 cellUtilCountLeadingZero(uint32 x)
-{
-    uint32 y;
-    uint32 n = 32;
-
-    y = x >> 16;
-    if (y != 0)
-    {
-        n = n - 16;
-        x = y;
-    }
-    y = x >>  8;
-    if (y != 0)
-    {
-        n = n -  8;
-        x = y;
-    }
-    y = x >>  4;
-    if (y != 0)
-    {
-        n = n -  4;
-        x = y;
-    }
-    y = x >>  2;
-    if (y != 0)
-    {
-        n = n -  2;
-        x = y;
-    }
-    y = x >>  1;
-    if (y != 0)
-    {
-        return n - 2;
-    }
-    return n - x;
-}
-
-inline uint32 cellUtilLog2(uint32 x)
-{
-    return 31 - cellUtilCountLeadingZero(x);
-}
-
-
-
-
-inline void convertSwizzle(uint8*& dst, const uint8*&    src,
-    const uint32 SrcPitch, const uint32 depth,
-    const uint32 xpos, const uint32 ypos,
-    const uint32 SciX1, const uint32 SciY1,
-    const uint32 SciX2, const uint32 SciY2,
-    const uint32 level)
-{
-    if (level == 1)
-    {
-        switch (depth)
-        {
-        case 16:
-            if (xpos >= SciX1 && xpos < SciX2 && ypos >= SciY1 && ypos < SciY2)
-            {
-                //                  *((uint32*&)dst)++ = ((uint32*)src)[ypos * width + xpos];
-                //                  *((uint32*&)dst)++ = ((uint32*)src)[ypos * width + xpos+1];
-                //                  *((uint32*&)dst)++ = ((uint32*)src)[ypos * width + xpos+2];
-                //                  *((uint32*&)dst)++ = ((uint32*)src)[ypos * width + xpos+3];
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 16)));
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 16 + 4)));
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 16 + 8)));
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 16 + 12)));
-            }
-            else
-            {
-                ((uint32*&)dst) += 4;
-            }
-            break;
-        case 8:
-            if (xpos >= SciX1 && xpos < SciX2 && ypos >= SciY1 && ypos < SciY2)
-            {
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 8)));
-                *((uint32*&)dst)++ = *((uint32*)(src + (ypos * SrcPitch + xpos * 8 + 4)));
-            }
-            else
-            {
-                ((uint32*&)dst) += 2;
-            }
-            break;
-        case 4:
-            if (xpos >= SciX1 && xpos < SciX2 && ypos >= SciY1 && ypos < SciY2)
-            {
-                *((uint32*&)dst) = *((uint32*)(src + (ypos * SrcPitch + xpos * 4)));
-            }
-            dst += 4;
-            break;
-        case 3:
-            if (xpos >= SciX1 && xpos < SciX2 && ypos >= SciY1 && ypos < SciY2)
-            {
-                *dst++ = src[ypos * SrcPitch + xpos * depth];
-                *dst++ = src[ypos * SrcPitch + xpos * depth + 1];
-                *dst++ = src[ypos * SrcPitch + xpos * depth + 2];
-            }
-            else
-            {
-                dst += 3;
-            }
-            break;
-        case 1:
-            if (xpos >= SciX1 && xpos < SciX2 && ypos >= SciY1 && ypos < SciY2)
-            {
-                *dst++ = src[ypos * SrcPitch + xpos * depth];
-            }
-            else
-            {
-                dst++;
-            }
-            break;
-        default:
-            assert(0);
-        }
-        return;
-    }
-    else
-    {
-        convertSwizzle(dst, src, SrcPitch, depth, xpos, ypos, SciX1, SciY1, SciX2, SciY2, level - 1);
-        convertSwizzle(dst, src, SrcPitch, depth, xpos + (1U << (level - 2)), ypos, SciX1, SciY1, SciX2, SciY2, level - 1);
-        convertSwizzle(dst, src, SrcPitch, depth, xpos, ypos + (1U << (level - 2)), SciX1, SciY1, SciX2, SciY2, level - 1);
-        convertSwizzle(dst, src, SrcPitch, depth, xpos + (1U << (level - 2)), ypos + (1U << (level - 2)), SciX1, SciY1, SciX2, SciY2, level - 1);
-    }
-}
-
-
-
-
-inline void Linear2Swizzle(uint8*   dst,
-    const uint8*     src,
-    const uint32 SrcPitch,
-    const uint32 width,
-    const uint32 height,
-    const uint32 depth,
-    const uint32 SciX1, const uint32 SciY1,
-    const uint32 SciX2, const uint32 SciY2)
-{
-    src -= SciY1 * SrcPitch + SciX1 * depth;
-    if (width == height)
-    {
-        convertSwizzle(dst, src, SrcPitch, depth, 0, 0, SciX1, SciY1, SciX2, SciY2, cellUtilLog2(width) + 1);
-    }
-    else
-    if (width > height)
-    {
-        uint32 baseLevel    = cellUtilLog2(width) - (cellUtilLog2(width) - cellUtilLog2(height));
-        for (uint32 i = 0; i < (1UL << (cellUtilLog2(width) - cellUtilLog2(height))); i++)
-        {
-            convertSwizzle(dst, src, SrcPitch, depth, (1U << baseLevel) * i, 0, SciX1, SciY1, SciX2, SciY2, baseLevel + 1);
-        }
-    }
-    else
-    //  if (width < height)//wtf
-    {
-        uint32 baseLevel    = cellUtilLog2(height) - (cellUtilLog2(height) - cellUtilLog2(width));
-        for (uint32 i = 0; i < (1UL << (cellUtilLog2(height) - cellUtilLog2(width))); i++)
-        {
-            convertSwizzle(dst, src, SrcPitch, depth, 0, (1U << baseLevel) * i, SciX1, SciY1, SciX2, SciY2, baseLevel + 1);
-        }
-    }
-}

Code/Legacy/CryCommon/Common_TypeInfo.cpp

@@ -1,21 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-#include "Cry_Geo.h"
-#include "Cry_Color.h"
-#include "Cry_Vector3.h"
-
-// Manually instantiate templates as needed here.
-template struct Vec3_tpl<float>;
-template struct Vec4_tpl<float>;
-template struct Vec2_tpl<float>;
-template struct Ang3_tpl<float>;
-template struct Plane_tpl<float>;
-template struct Matrix33_tpl<float>;
-template struct Color_tpl<float>;

Code/Legacy/CryCommon/CryCrc32.h

@@ -1,210 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-#pragma once
-
-#include "BaseTypes.h"
-
-// CRC-32
-//
-// Polynomial:
-//   0x04C11DB7
-//   x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
-//
-// Validation:
-//   CCrc32::Compute("123456789") == 0xCBF43926
-//
-// Examples of using:
-//
-//   printf("crc32: %08x\n", (unsigned)CCrc32::Compute(ptr, size));
-//
-//   CCrc32 crc;
-//   crc.Add(ptr0, size0);
-//   crc.Add(ptr1, size1);
-//   printf("crc32: %08x\n", (unsigned)crc.Get());
-
-class CCrc32
-{
-public:
-    static uint32 Compute(const void* const pData, const size_t sizeInBytes)
-    {
-        CCrc32 c;
-        c.Add(pData, sizeInBytes);
-        return c.Get();
-    }
-
-    static uint32 Compute(const char* const szData)
-    {
-        CCrc32 c;
-        c.Add(szData);
-        return c.Get();
-    }
-
-    static uint32 ComputeLowercase(const char* const pData, const size_t sizeInBytes)
-    {
-        CCrc32 c;
-        c.AddLowercase(pData, sizeInBytes);
-        return c.Get();
-    }
-
-    static uint32 ComputeLowercase(const char* const szData)
-    {
-        CCrc32 c;
-        c.AddLowercase(szData);
-        return c.Get();
-    }
-
-
-    CCrc32()
-        : m_crc(0xFFFFffff)
-        , m_pTable(GetTable())
-    {
-    }
-
-    CCrc32(unsigned int initializer)
-        : m_crc(initializer)
-        , m_pTable(GetTable())
-    {
-    }
-
-    void Reset()
-    {
-        m_crc = 0xFFFFffff;
-    }
-
-    uint32 Get() const
-    {
-        return ~m_crc;
-    }
-
-    unsigned int Add(const void* const pData, size_t sizeInBytes)
-    {
-        const uint8* p = (const uint8*)pData;
-        while (sizeInBytes--)
-        {
-            m_crc = (m_crc >> 8) ^ m_pTable[(m_crc & 0xFF) ^ (*p++)];
-        }
-        return Get();
-    }
-
-    unsigned int Add(const char* szData)
-    {
-        while (*szData)
-        {
-            m_crc = (m_crc >> 8) ^ m_pTable[(m_crc & 0xFF) ^ uint8(*szData++)];
-        }
-        return Get();
-    }
-
-#if defined(CRY_TMP_ASCII_TO_LOWER)
-#   error CRY_TMP_ASCII_TO_LOWER already defined
-#endif
-#define CRY_TMP_ASCII_TO_LOWER(c)  uint8(((c) <= 'Z' && (c) >= 'A') ? (c) + ('a' - 'A') : (c))
-
-    unsigned int AddLowercase(const char* pData, size_t sizeInBytes)
-    {
-        while (sizeInBytes--)
-        {
-            const uint8 c = *pData++;
-            m_crc = (m_crc >> 8) ^ m_pTable[(m_crc & 0xFF) ^ CRY_TMP_ASCII_TO_LOWER(c)];
-        }
-        return Get();
-    }
-
-    unsigned int AddLowercase(const char* szData)
-    {
-        while (*szData)
-        {
-            const uint8 c = *szData++;
-            m_crc = (m_crc >> 8) ^ m_pTable[(m_crc & 0xFF) ^ CRY_TMP_ASCII_TO_LOWER(c)];
-        }
-        return Get();
-    }
-
-#undef CRY_TMP_ASCII_TO_LOWER
-
-private:
-    static const uint32* GetTable()
-    {
-        static const uint32 table[256] =
-        {
-            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
-            0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
-            0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
-            0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
-            0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
-            0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-            0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
-            0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
-            0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
-            0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
-            0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
-            0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-            0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
-            0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
-            0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
-            0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
-            0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
-            0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-            0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
-            0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
-            0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-            0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
-            0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
-            0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-            0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
-            0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
-            0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
-            0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
-            0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
-            0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-            0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
-            0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
-            0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
-            0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
-            0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
-            0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-            0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
-            0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
-            0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
-            0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
-            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
-            0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-            0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
-            0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
-            0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
-            0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
-            0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
-            0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-            0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
-            0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
-            0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
-            0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
-            0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
-            0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-            0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
-            0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
-            0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
-            0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
-            0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
-            0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-            0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
-            0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
-            0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-            0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-        };
-        return &table[0];
-    }
-
-private:
-    uint32 m_crc;
-    const uint32* const m_pTable;
-};
-
-// eof

Code/Legacy/CryCommon/CryEndian.h

@@ -6,9 +6,6 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRYENDIAN_H
-#define CRYINCLUDE_CRYCOMMON_CRYENDIAN_H
 #pragma once
 
 #include <BaseTypes.h>
@@ -68,18 +65,6 @@ enum EEndianness
 #endif
 };
 
-
-// Legacy macros
-#define GetPlatformEndian() false
-
-/////////////////////////////////////////////////////////////////////////////////////
-
-inline bool IsSystemLittleEndian()
-{
-    const int a = 1;
-    return 1 == *(const char*)&a;
-}
-
 /////////////////////////////////////////////////////////////////////////////////////
 
 // SwapEndian function, using TypeInfo.
@@ -233,63 +218,3 @@ inline void SwapEndian(T& t, bool bSwapEndian = eLittleEndian)
         SwapEndianBase(&t, 1);
     }
 }
-
-template<class T>
-inline T SwapEndianValue(T t, bool bSwapEndian = eLittleEndian)
-{
-    if (bSwapEndian)
-    {
-        SwapEndianBase(&t, 1);
-    }
-    return t;
-}
-
-//---------------------------------------------------------------------------
-// Object-oriented data extraction for endian-swapping reading.
-template<class T, class D>
-inline T* StepData(D*& pData, size_t nCount, bool bSwapEndian)
-{
-    T* Elems = (T*)pData;
-    SwapEndian(Elems, nCount, bSwapEndian);
-    pData = (D*)((T*)pData + nCount);
-    return Elems;
-}
-
-template<class T, class D>
-inline T* StepData(D*& pData, bool bSwapEndian)
-{
-    return StepData<T, D>(pData, 1, bSwapEndian);
-}
-
-template<class T, class D>
-inline void StepData(T*& Result, D*& pData, size_t nCount, bool bSwapEndian)
-{
-    Result = StepData<T, D>(pData, nCount, bSwapEndian);
-}
-
-template<class T, class D>
-inline void StepDataCopy(T* Dest, D*& pData, size_t nCount, bool bSwapEndian)
-{
-    memcpy(Dest, pData, nCount * sizeof(T));
-    SwapEndian(Dest, nCount, bSwapEndian);
-    pData = (D*)((T*)pData + nCount);
-}
-
-template<class T, class D>
-inline void StepDataWrite(D*& pDest, const T* aSrc, size_t nCount, bool bSwapEndian)
-{
-    memcpy(pDest, aSrc, nCount * sizeof(T));
-    if (bSwapEndian)
-    {
-        SwapEndianBase((T*)pDest, nCount, true);
-    }
-    (T*&)pDest += nCount;
-}
-
-template<class T, class D>
-inline void StepDataWrite(D*& pDest, const T& Src, bool bSwapEndian)
-{
-    StepDataWrite(pDest, &Src, 1, bSwapEndian);
-}
-
-#endif // CRYINCLUDE_CRYCOMMON_CRYENDIAN_H

Code/Legacy/CryCommon/CryFile.h

@@ -6,12 +6,7 @@
  *
  */
 
-
 // Description : File wrapper.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRYFILE_H
-#define CRYINCLUDE_CRYCOMMON_CRYFILE_H
 #pragma once
 
 #include <CryPath.h>
@@ -20,86 +15,16 @@
 #include <IConsole.h>
 #include <AzCore/IO/FileIO.h>
 
-//////////////////////////////////////////////////////////////////////////
-// Defines for CryEngine filetypes extensions.
-//////////////////////////////////////////////////////////////////////////
-#define CRY_GEOMETRY_FILE_EXT                    "cgf"
-#define CRY_SKEL_FILE_EXT                        "chr" //will be a SKEL soon
-#define CRY_SKIN_FILE_EXT                        "skin"
-#define CRY_CHARACTER_ANIMATION_FILE_EXT         "caf"
-#define CRY_CHARACTER_DEFINITION_FILE_EXT        "cdf"
-#define CRY_CHARACTER_LIST_FILE_EXT              "cid"
-#define CRY_ANIM_GEOMETRY_FILE_EXT               "cga"
-#define CRY_ANIM_GEOMETRY_ANIMATION_FILE_EXT     "anm"
-#define CRY_COMPILED_FILE_EXT                    "(c)"
-#define CRY_BINARY_XML_FILE_EXT                  "binxml"
-#define CRY_XML_FILE_EXT                         "xml"
-#define CRY_CHARACTER_PARAM_FILE_EXT             "chrparams"
-#define CRY_GEOM_CACHE_FILE_EXT                  "cax"
 //////////////////////////////////////////////////////////////////////////
 #define CRYFILE_MAX_PATH                         260
 //////////////////////////////////////////////////////////////////////////
 
-inline const char* CryGetExt(const char* filepath)
-{
-    const char* str = filepath;
-    size_t len = strlen(filepath);
-    for (const char* p = str + len - 1; p >= str; --p)
-    {
-        switch (*p)
-        {
-        case ':':
-        case '/':
-        case '\\':
-            // we've reached a path separator - it means there's no extension in this name
-            return "";
-        case '.':
-            // there's an extension in this file name
-            return p + 1;
-        }
-    }
-    return "";
-}
-
-// Summary:
-//   Checks if specified file name is a character file.
-// Summary:
-//   Checks if specified file name is a character file.
-inline bool IsCharacterFile(const char* filename)
-{
-    const char* ext = CryGetExt(filename);
-    if (_stricmp(ext, CRY_SKEL_FILE_EXT) == 0 || _stricmp(ext, CRY_SKIN_FILE_EXT) == 0 || _stricmp(ext, CRY_CHARACTER_DEFINITION_FILE_EXT) == 0 || _stricmp(ext, CRY_ANIM_GEOMETRY_FILE_EXT) == 0)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-// Description:
-//   Checks if specified file name is a static geometry file.
-inline bool IsStatObjFile(const char* filename)
-{
-    const char* ext = CryGetExt(filename);
-    if (_stricmp(ext, CRY_GEOMETRY_FILE_EXT) == 0)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
 // Summary:
 //   Wrapper on file system.
 class CCryFile
 {
 public:
     CCryFile();
-    CCryFile(AZ::IO::IArchive* pIArchive);    // allow an alternative IArchiveinterface
     CCryFile(const char* filename, const char* mode);
     ~CCryFile();
 
@@ -112,13 +37,6 @@ public:
     // Summary:
     //   Reads data from a file at the current file position.
     size_t ReadRaw(void* lpBuf, size_t nSize);
-    // Summary:
-    //   Template version, for automatic size support.
-    template<class T>
-    inline size_t ReadTypeRaw(T* pDest, size_t nCount = 1)
-    {
-        return ReadRaw(pDest, sizeof(T) * nCount);
-    }
 
     // Summary:
     //   Automatic endian-swapping version.
@@ -137,27 +55,6 @@ public:
     // Summary:
     //   Moves the current file pointer to the specified position.
     size_t Seek(size_t seek, int mode);
-    // Summary:
-    //   Moves the current file pointer at the beginning of the file.
-    void SeekToBegin();
-    // Summary:
-    //   Moves the current file pointer at the end of the file.
-    size_t SeekToEnd();
-    // Summary:
-    //   Retrieves the current file pointer.
-    size_t GetPosition();
-
-    // Summary:
-    //   Tests for end-of-file on a selected file.
-    bool IsEof();
-
-    // Summary:
-    //   Flushes any data yet to be written.
-    void Flush();
-
-    // Summary:
-    //   Gets a handle to a pack object.
-    AZ::IO::HandleType GetHandle() const { return m_fileHandle; };
 
     // Description:
     //    Retrieves the filename of the selected file.
@@ -193,12 +90,6 @@ inline CCryFile::CCryFile()
     m_pIArchive = gEnv ? gEnv->pCryPak : NULL;
 }
 
-inline CCryFile::CCryFile(AZ::IO::IArchive* pIArchive)
-{
-    m_fileHandle = AZ::IO::InvalidHandle;
-    m_pIArchive = pIArchive;
-}
-
 //////////////////////////////////////////////////////////////////////////
 inline CCryFile::CCryFile(const char* filename, const char* mode)
 {
@@ -336,58 +227,6 @@ inline size_t CCryFile::Seek(size_t seek, int mode)
     return 1;
 }
 
-//////////////////////////////////////////////////////////////////////////
-inline void CCryFile::SeekToBegin()
-{
-    Seek(0, SEEK_SET);
-}
-
-//////////////////////////////////////////////////////////////////////////
-inline size_t CCryFile::SeekToEnd()
-{
-    return Seek(0, SEEK_END);
-}
-
-//////////////////////////////////////////////////////////////////////////
-inline size_t CCryFile::GetPosition()
-{
-    assert(m_fileHandle != AZ::IO::InvalidHandle);
-    if (m_pIArchive)
-    {
-        return m_pIArchive->FTell(m_fileHandle);
-    }
-
-    AZ::u64 tellOffset = 0;
-    AZ::IO::FileIOBase::GetInstance()->Tell(m_fileHandle, tellOffset);
-
-    return static_cast<size_t>(tellOffset);
-}
-
-//////////////////////////////////////////////////////////////////////////
-inline bool CCryFile::IsEof()
-{
-    assert(m_fileHandle != AZ::IO::InvalidHandle);
-    if (m_pIArchive)
-    {
-        return m_pIArchive->FEof(m_fileHandle) != 0;
-    }
-    
-    return AZ::IO::FileIOBase::GetInstance()->Eof(m_fileHandle);
-}
-
-//////////////////////////////////////////////////////////////////////////
-inline void CCryFile::Flush()
-{
-    assert(m_fileHandle != AZ::IO::InvalidHandle);
-
-    if (m_pIArchive)
-    {
-        m_pIArchive->FFlush(m_fileHandle);
-    }
-    
-    AZ::IO::FileIOBase::GetInstance()->Flush(m_fileHandle);
-}
-
 //////////////////////////////////////////////////////////////////////////
 inline bool CCryFile::IsInPak() const
 {
@@ -433,5 +272,3 @@ inline const char* CCryFile::GetAdjustedFilename() const
     }
     return szAdjustedFile;
 }
-
-#endif // CRYINCLUDE_CRYCOMMON_CRYFILE_H

Code/Legacy/CryCommon/CryHalf.inl

@@ -15,7 +15,6 @@
 
 
 typedef uint16 CryHalf;
-class ICrySizer;
 
 typedef union floatint_union
 {
@@ -138,9 +137,6 @@ struct CryHalf2
     {
         return x != rhs.x || y != rhs.y;
     }
-
-    void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const {}
-
 };
 
 struct CryHalf4
@@ -193,9 +189,6 @@ struct CryHalf4
     {
         return x != rhs.x || y != rhs.y || z != rhs.z || w != rhs.w;
     }
-
-    void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const {}
-
 };
 
 #endif // #ifndef CRY_HALF_INL

Code/Legacy/CryCommon/CryListenerSet.h

@@ -21,7 +21,8 @@
 #pragma once
 
 
-#include <CrySizer.h>
+#include "Cry_Math.h"
+#include <StlUtils.h>
 /************************************************************************
 
 Core elements:
@@ -151,13 +152,6 @@ public:
     // Allow TListeners::Notifier style usage
     typedef class CListenerNotifier<T> Notifier;
 
-    void GetMemoryUsage(ICrySizer* pSizer) const
-    {
-        pSizer->AddContainer(m_listeners);
-#if defined(CRY_LISTENERSET_DEBUG)
-        pSizer->AddContainer(m_allocatedNames);
-#endif
-    }
 private:    // DO NOT REMOVE - following methods only to be accessed only via CNotifier
 
     struct ListenerRecord

Code/Legacy/CryCommon/CryPodArray.h

@@ -1,212 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Simple POD types container
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRYPODARRAY_H
-#define CRYINCLUDE_CRYCOMMON_CRYPODARRAY_H
-#pragma once
-
-#include <AzCore/std/containers/vector.h>
-
-//////////////////////////////////////////////////////////////////////////
-// POD Array
-// vector like class (random access O(1)) without construction/destructor/copy constructor/assignment handling
-// over-allocation allows safe prefetching where required without worrying about memory page boundaries
-//////////////////////////////////////////////////////////////////////////
-template <class T, size_t overAllocBytes = 0>
-class PodArray
-{
-    AZStd::vector<T> m_elements;
-
-public:
-    typedef T        value_type;
-    typedef T*       iterator;
-    typedef const T* const_iterator;
-
-    //////////////////////////////////////////////////////////////////////////
-    // STL compatible interface
-    //////////////////////////////////////////////////////////////////////////
-    void resize(size_t numElements)
-    {
-        m_elements.resize(numElements);
-    }
-    //////////////////////////////////////////////////////////////////////////
-    ILINE void reserve(unsigned numElements) { m_elements.reserve(numElements); }
-    ILINE void push_back(const T& rElement) { m_elements.push_back(rElement); }
-    ILINE size_t size() const   { return m_elements.size(); }
-    ILINE size_t capacity() const { return m_elements.capacity(); }
-
-    ILINE void clear() { m_elements.clear(); }
-    ILINE T* begin() { return m_elements.begin(); }
-    ILINE T* end() { return m_elements.end(); }
-    ILINE const T* begin() const { return m_elements.begin(); }
-    ILINE const T* end() const { return m_elements.end(); }
-    ILINE bool empty() const { return m_elements.empty(); }
-
-    ILINE const T& front() const { return m_elements.front(); }
-    ILINE T& front() { return m_elements.front(); }
-
-    ILINE const T& back() const { return m_elements.back(); }
-    ILINE T& back() { return m_elements.back(); }
-    //////////////////////////////////////////////////////////////////////////
-
-    //////////////////////////////////////////////////////////////////////////
-    PodArray()
-        : m_elements()
-    {
-    }
-    PodArray(int elem_count, int nNewCount = 0)
-    {
-        m_elements.reserve(elem_count);
-        m_elements.resize(nNewCount);
-    }
-    PodArray(const PodArray<T>& from)
-        : m_elements(from.m_elements)
-    {
-    }
-    ~PodArray()
-    {
-    }
-
-    void Reset() { m_elements.clear(); }
-    void Free()
-    {
-        m_elements.clear();
-        m_elements.shrink_to_fit();
-    }
-
-    ILINE void Clear()
-    {
-        m_elements.clear();
-    }
-
-    int Find(const T& p)
-    {
-        const auto it = AZStd::find(m_elements.begin(), m_elements.end(), p);
-        if (it != m_elements.end())
-        {
-            return static_cast<int>(AZStd::distance(m_elements.begin(), it));
-        }
-        return -1;
-    }
-
-    inline void AddList(const PodArray<T>& lstAnother)
-    {
-        AZStd::copy(lstAnother.m_elements.begin(), lstAnother.m_elements.end(), AZStd::back_inserter(m_elements));
-    }
-
-    inline void AddList(T* pAnotherArray, int nAnotherCount)
-    {
-        AZStd::copy(pAnotherArray, pAnotherArray + nAnotherCount, AZStd::back_inserter(m_elements));
-    }
-
-    ILINE void Add(const T& p)
-    {
-        m_elements.push_back(p);
-    }
-
-    ILINE T& AddNew()
-    {
-        m_elements.emplace_back();
-        return m_elements.back();
-    }
-
-    void InsertBefore(const T& p, const unsigned int nBefore)
-    {
-        m_elements.insert(m_elements.begin() + nBefore, p);
-    }
-
-    void CheckAllocated(int elem_count)
-    {
-        if (m_elements.size() < elem_count)
-        {
-            m_elements.resize(elem_count);
-        }
-    }
-
-    void PreAllocate(int elem_count, int nNewCount = -1)
-    {
-        m_elements.reserve(elem_count);
-        if (nNewCount >= 0)
-        {
-            m_elements.resize(nNewCount);
-        }
-    }
-
-    inline void Delete(const int nElemId, const int nElemCount = 1)
-    {
-        AZ_Assert(nElemId >= 0 && nElemId + nElemCount <= size(), "Index out of bounds");
-        m_elements.erase(m_elements.begin() + nElemId, m_elements.begin() + nElemId + nElemCount);
-    }
-
-    inline void DeleteFastUnsorted(const int nElemId, const int nElemCount = 1)
-    {
-        AZ_Assert(nElemId >= 0 && nElemId + nElemCount <= size(), "Index out of bounds");
-        m_elements.erase(m_elements.begin() + nElemId, m_elements.begin() + nElemId + nElemCount);
-    }
-
-    inline bool Delete(const T& del)
-    {
-        const size_t numElements = m_elements.size();
-        m_elements.erase(std::remove(m_elements.begin(), m_elements.end(), del), m_elements.end());
-        return numElements != 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(); }
-
-    ILINE  const T& operator [] (int i) const { return m_elements[i]; }
-    ILINE  T& operator [] (int i) { return m_elements[i]; }
-    ILINE  const T& GetAt(int i) const { return m_elements[i]; }
-    ILINE  T& GetAt(int i) { return m_elements[i]; }
-    ILINE  const T* Get(int i) const { return &m_elements[i]; }
-    ILINE  T* Get(int i) { return &m_elements[i]; }
-    ILINE  const T* GetElements() const { return m_elements.data(); }
-    ILINE  T* GetElements() { return m_elements.data(); }
-    
-    ILINE  unsigned int GetDataSize() const { return m_elements.size() * sizeof(T); }
-
-    const T& Last() const { return m_elements.back(); }
-    T& Last() { return m_elements.back(); }
-
-    ILINE void DeleteLast()
-    {
-        assert(!m_elements.empty());
-        m_elements.pop_back();
-    }
-
-    PodArray<T>& operator=(const PodArray<T>& source_list)
-    {
-        m_elements = source_list.m_elements;
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Return true if arrays have the same data.
-    bool Compare(const PodArray<T>& l) const
-    {
-        return m_elements == l.m_elements;
-    }
-
-    // for statistics
-    ILINE size_t ComputeSizeInMemory() const
-    {
-        return (sizeof(*this) + sizeof(T) * m_elements.capacity()) + overAllocBytes;
-    }
-
-    ILINE void RemoveIf(AZStd::function<bool(const T&)> testFunc)
-    {
-        m_elements.erase(AZStd::remove_if(m_elements.begin(), m_elements.end(), testFunc), m_elements.end());
-    }
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_CRYPODARRAY_H

Code/Legacy/CryCommon/CrySizer.h

@@ -1,563 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Declaration and definition of the CrySizer class, which is used to
-//               calculate the memory usage by the subsystems and components, to help
-//               the artists keep the memory budged low.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRYSIZER_H
-#define CRYINCLUDE_CRYCOMMON_CRYSIZER_H
-#pragma once
-
-
-//////////////////////////////////////////////////////////////////////////
-
-// common containers for overloads
-#include <list>
-
-#include "Cry_Math.h"
-#include <StlUtils.h>
-#include <CryPodArray.h>
-#include <Cry_Vector3.h>
-#include <Cry_Quat.h>
-#include <Cry_Color.h>
-#include <smartptr.h>
-#include <AzCore/std/smart_ptr/shared_ptr.h>
-
-// forward declarations for overloads
-struct AABB;
-struct SVF_P3F;
-struct SVF_P3F_C4B_T2F;
-struct SVF_P3S_C4B_T2S;
-struct SPipTangents;
-
-#ifdef WIN64
-#include <string.h> // workaround for Amd64 compiler
-#endif
-
-namespace AZ
-{
-    class Vector3;
-}
-
-// flags applicable to the ICrySizer (retrieved via getFlags() method)
-//
-enum ICrySizerFlagsEnum
-{
-    // if this flag is set, during getSize(), the subsystem must count all the objects
-    // it uses in the other subsystems also
-    CSF_RecurseSubsystems = 1 << 0,
-
-    CSF_Reserved1 = 1 << 1,
-    CSF_Reserved2 = 1 << 2
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Helper functions to calculate size of the std containers.
-//////////////////////////////////////////////////////////////////////////
-namespace stl
-{
-    template <class Map>
-    inline size_t size_of_map(const Map& m)
-    {
-        if (!m.empty())
-        {
-            return m.size() * sizeof(typename Map::value_type) + m.size() * sizeof(MapLikeStruct);
-        }
-        return 0;
-    }
-    template <class Map>
-    inline size_t size_of_set(const Map& m)
-    {
-        if (!m.empty())
-        {
-            return m.size() * sizeof(typename Map::value_type) + m.size() * sizeof(MapLikeStruct);
-        }
-        return 0;
-    }
-    template <class List>
-    inline size_t size_of_list(const List& c)
-    {
-        if (!c.empty())
-        {
-            return c.size() * sizeof(typename List::value_type) + c.size() * sizeof(void*) * 2; // sizeof stored type + 2 pointers prev,next
-        }
-        return 0;
-    }
-    template <class Deque>
-    inline size_t size_of_deque(const Deque& c)
-    {
-        if (!c.empty())
-        {
-            return c.size() * sizeof(typename Deque::value_type);
-        }
-        return 0;
-    }
-};
-
-//////////////////////////////////////////////////////////////////////////
-// interface ICrySizer
-// USAGE
-//   An instance of this class is passed down to each and every component in the system.
-//   Every component it's passed to optionally pushes its name on top of the
-//     component name stack (thus ensuring that all the components calculated down
-//     the tree will be assigned the correct subsystem/component name)
-//   Every component must Add its size with one of the Add* functions, and Add the
-//     size of all its subcomponents recursively
-//   In order to push the component/system name on the name stack, the clients must
-//     use the SIZER_COMPONENT_NAME macro or CrySizerComponentNameHelper class:
-//
-//   void X::getSize (ICrySizer* pSizer)
-//   {
-//     SIZER_COMPONENT_NAME(pSizer, X);
-//     if (!pSizer->Add (this))
-//       return;
-//     pSizer->Add (m_arrMySimpleArray);
-//     pSizer->Add (m_setMySimpleSet);
-//     m_pSubobject->getSize (pSizer);
-//   }
-//
-//   The Add* functions return bool. If they return true, then the object has been added
-//   to the set for the first time, and you should go on recursively adding all its children.
-//   If it returns false, then you can spare time and rather not go on into recursion;
-//   however it doesn't reflect on the results: an object that's added more than once is
-//   counted only once.
-//
-// WARNING:
-//   If you have an array (pointer), you should Add its size with addArray
-class ICrySizer
-{
-public:
-    virtual ~ICrySizer(){}
-    // this class is used to push/pop the name to/from the stack automatically
-    // (to exclude stack overruns or underruns at runtime)
-    friend class CrySizerComponentNameHelper;
-
-    virtual void Release() = 0;
-
-    // Return total calculated size.
-    virtual size_t GetTotalSize() = 0;
-
-    // Return total objects added.
-    virtual size_t GetObjectCount() = 0;
-
-    // Resets the counting.
-    virtual void Reset() = 0;
-
-    virtual void End() = 0;
-
-    // adds an object identified by the unique pointer (it needs not be
-    // the actual object position in the memory, though it would be nice,
-    // but it must be unique throughout the system and unchanging for this object)
-    // nCount parameter is only used for counting number of objects, it doesnt affect the size of the object.
-    // RETURNS: true if the object has actually been added (for the first time)
-    //          and calculated
-    virtual bool AddObject (const void* pIdentifier, size_t nSizeBytes, int nCount = 1) = 0;
-
-    template<typename Type>
-    bool AddObjectSize(const Type* pObj)
-    {
-        return AddObject(pObj, sizeof *pObj);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////
-    // temp dummy function while checking in the CrySizer changes, will be removed soon
-
-    template<typename Type>
-    void AddObject(const Type& rObj)
-    {
-        (void)rObj;
-    }
-
-    template<typename Type>
-    void AddObject(Type* pObj)
-    {
-        if (pObj)
-        {
-            //forward to reference object to allow function overload
-            this->AddObject(*pObj);
-        }
-    }
-
-    // overloads for smart_ptr and other common objects
-    template<typename T>
-    void AddObject(const _smart_ptr<T>& rObj) { this->AddObject(rObj.get()); }
-    template<typename T>
-    void AddObject(const AZStd::shared_ptr<T>& rObj) { this->AddObject(rObj.get()); }
-    template<typename T>
-    void AddObject(const std::shared_ptr<T>& rObj) { this->AddObject(rObj.get()); }
-    template<typename T>
-    void AddObject(const std::unique_ptr<T>& rObj) { this->AddObject(rObj.get()); }
-    template<typename T, typename U>
-    void AddObject(const std::pair<T, U>& rPair)
-    {
-        this->AddObject(rPair.first);
-        this->AddObject(rPair.second);
-    }
-    template<typename T, typename U>
-    void AddObject(const AZStd::pair<T, U>& rPair)
-    {
-        this->AddObject(rPair.first);
-        this->AddObject(rPair.second);
-    }
-    void AddObject(const AZStd::string& rString) {this->AddObject(rString.c_str(), rString.capacity()); }
-    void AddObject(const wchar_t&) {}
-    void AddObject(const char&) {}
-    void AddObject(const unsigned char&) {}
-    void AddObject(const signed char&) {}
-    void AddObject(const short&) {}
-    void AddObject(const unsigned short&) {}
-    void AddObject(const int&) {}
-    void AddObject(const unsigned int&) {}
-    void AddObject(const long&) {}
-    void AddObject(const unsigned long&) {}
-    void AddObject(const float&) {}
-    void AddObject(const bool&) {}
-    void AddObject(const unsigned long long&) {}
-    void AddObject(const long long&) {}
-    void AddObject(const double&) {}
-    void AddObject(const Vec2&) {}
-    void AddObject(const Vec3&) {}
-    void AddObject(const Vec4&) {}
-    void AddObject(const Ang3&) {}
-    void AddObject(const Matrix34&) {}
-    void AddObject(const Quat&) {}
-    void AddObject(const QuatT&) {}
-    void AddObject(const QuatTS&) {}
-    void AddObject(const ColorF&) {}
-    void AddObject(const AABB&) {}
-    void AddObject(const SVF_P3F&) {}
-    void AddObject(const SVF_P3F_C4B_T2F&) {}
-    void AddObject(const SVF_P3S_C4B_T2S&) {}
-    void AddObject(const SPipTangents&) {}
-    void AddObject([[maybe_unused]] const AZ::Vector3& rObj) {}
-    void AddObject(void*) {}
-
-    // overloads for container, will automaticly traverse the content
-    template<typename T, typename Alloc>
-    void AddObject(const std::list<T, Alloc>& rList)
-    {
-        // dummy struct to get correct element size
-        struct Dummy
-        {
-            void* a;
-            void* b;
-            T t;
-        };
-
-        for (typename std::list<T, Alloc>::const_iterator it = rList.begin(); it != rList.end(); ++it)
-        {
-            if (this->AddObject(&(*it), sizeof(Dummy)))
-            {
-                this->AddObject(*it);
-            }
-        }
-    }
-    template<typename K, typename T, typename Comp, typename Equal, typename Alloc>
-    void AddObject([[maybe_unused]] const AZStd::unordered_map<K, T, Comp, Equal, Alloc>& rVector)
-    {
-
-    }
-
-    template<typename T, typename Alloc>
-    void AddObject(const std::vector<T, Alloc>& rVector)
-    {
-        if (rVector.empty())
-        {
-            this->AddObject(&rVector, rVector.capacity() * sizeof(T));
-            return;
-        }
-
-        if (!this->AddObject(&rVector[0], rVector.capacity() * sizeof(T)))
-        {
-            return;
-        }
-
-        for (typename std::vector<T, Alloc>::const_iterator it = rVector.begin(); it != rVector.end(); ++it)
-        {
-            this->AddObject(*it);
-        }
-    }
-
-    template<typename T, typename Alloc>
-    void AddObject(const std::deque<T, Alloc>& rVector)
-    {
-        for (typename std::deque<T, Alloc>::const_iterator it = rVector.begin(); it != rVector.end(); ++it)
-        {
-            if (this->AddObject(&(*it), sizeof(T)))
-            {
-                this->AddObject(*it);
-            }
-        }
-    }
-
-    template<typename T>
-    void AddObject(const PodArray<T>& rVector)
-    {
-        if (!this->AddObject(rVector.begin(), rVector.capacity() * sizeof(T)))
-        {
-            return;
-        }
-
-        for (typename PodArray<T>::const_iterator it = rVector.begin(); it != rVector.end(); ++it)
-        {
-            this->AddObject(*it);
-        }
-    }
-
-    template<typename K, typename T, typename Comp, typename Alloc>
-    void AddObject(const std::map<K, T, Comp, Alloc>& rVector)
-    {
-        // dummy struct to get correct element size
-        struct Dummy
-        {
-            void* a;
-            void* b;
-            void* c;
-            void* d;
-            K k;
-            T t;
-        };
-
-        for (typename std::map<K, T, Comp, Alloc>::const_iterator it = rVector.begin(); it != rVector.end(); ++it)
-        {
-            if (this->AddObject(&(*it), sizeof(Dummy)))
-            {
-                this->AddObject(it->first);
-                this->AddObject(it->second);
-            }
-        }
-    }
-
-    template<typename T, typename Comp, typename Alloc>
-    void AddObject(const std::set<T, Comp, Alloc>& rVector)
-    {
-        // dummy struct to get correct element size
-        struct Dummy
-        {
-            void* a;
-            void* b;
-            void* c;
-            void* d;
-            T t;
-        };
-
-        for (typename std::set<T, Comp, Alloc>::const_iterator it = rVector.begin(); it != rVector.end(); ++it)
-        {
-            if (this->AddObject(&(*it), sizeof(Dummy)))
-            {
-                this->AddObject(*it);
-            }
-        }
-    }
-
-    template <typename TKey, typename TValue, typename TPredicate, typename TAlloc>
-    void AddObject (const std::multimap<TKey, TValue, TPredicate, TAlloc>& rContainer)
-    {
-        AddContainer(rContainer);
-    }
-    ////////////////////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    bool Add (const T* pId, size_t num)
-    {
-        return AddObject(pId, num * sizeof(T));
-    }
-
-    template <class T>
-    bool Add (const T& rObject)
-    {
-        return AddObject (&rObject, sizeof(T));
-    }
-
-    bool Add (const char* szText)
-    {
-        return AddObject(szText, strlen(szText) + 1);
-    }
-
-    template <class StringCls>
-    bool AddString (const StringCls& strText)
-    {
-        if (!strText.empty())
-        {
-            return AddObject (strText.c_str(), strText.size());
-        }
-        else
-        {
-            return false;
-        }
-    }
-#ifdef _XSTRING_
-    template <class Elem, class Traits, class Allocator>
-    bool Add (const std::basic_string<Elem, Traits, Allocator>& strText)
-    {
-        AddString (strText);
-        return true;
-    }
-#endif
-
- #ifndef NOT_USE_CRY_STRING
-    bool Add (const AZStd::string& strText)
-    {
-        AddString(strText);
-        return true;
-    }
- #endif
-
-
-    // Template helper function to add generic stl container
-    template <typename Container>
-    bool AddContainer (const Container& rContainer)
-    {
-        if (rContainer.capacity())
-        {
-            return AddObject (&rContainer, rContainer.capacity() * sizeof(typename Container::value_type));
-        }
-        return false;
-    }
-    template <typename Container>
-    bool AddHashMap(const Container& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject (&(*rContainer.begin()), rContainer.size() * sizeof(typename Container::value_type));
-        }
-        return false;
-    }
-
-    // Specialization of the AddContainer for the std::list
-    template <typename Type, typename TAlloc>
-    bool AddContainer (const std::list<Type, TAlloc>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), stl::size_of_list(rContainer));
-        }
-        return false;
-    }
-    // Specialization of the AddContainer for the std::deque
-    template <typename Type, typename TAlloc>
-    bool AddContainer (const std::deque<Type, TAlloc>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), stl::size_of_deque(rContainer));
-        }
-        return false;
-    }
-    // Specialization of the AddContainer for the std::map
-    template <typename TKey, typename TValue, typename TPredicate, typename TAlloc>
-    bool AddContainer (const std::map<TKey, TValue, TPredicate, TAlloc>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), stl::size_of_map(rContainer));
-        }
-        return false;
-    }
-    // Specialization of the AddContainer for the std::multimap
-    template <typename TKey, typename TValue, typename TPredicate, typename TAlloc>
-    bool AddContainer (const std::multimap<TKey, TValue, TPredicate, TAlloc>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), stl::size_of_map(rContainer));
-        }
-        return false;
-    }
-    // Specialization of the AddContainer for the std::set
-    template <typename TKey, typename TPredicate, typename TAlloc>
-    bool AddContainer (const std::set<TKey, TPredicate, TAlloc>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), stl::size_of_set(rContainer));
-        }
-        return false;
-    }
-
-    // Specialization of the AddContainer for the AZStd::unordered_map
-    template <typename KEY, typename TYPE, class HASH, class EQUAL, class ALLOCATOR>
-    bool AddContainer(const AZStd::unordered_map<KEY, TYPE, HASH, EQUAL, ALLOCATOR>& rContainer)
-    {
-        if (!rContainer.empty())
-        {
-            return AddObject(&(*rContainer.begin()), rContainer.size() * sizeof(typename AZStd::unordered_map<KEY, TYPE, HASH, EQUAL, ALLOCATOR>::value_type));
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    void Test()
-    {
-        std::map<int, float> mymap;
-        AddContainer(mymap);
-    }
-
-    // returns the flags
-    unsigned GetFlags() const {return m_nFlags; }
-
-protected:
-    // these functions must operate on the component name stack
-    // they are to be only accessible from within class CrySizerComponentNameHelper
-    // which should be used through macro SIZER_COMPONENT_NAME
-    virtual void Push (const char* szComponentName) = 0;
-    // pushes the name that is the name of the previous component . (dot) this name
-    virtual void PushSubcomponent (const char* szSubcomponentName) = 0;
-    virtual void Pop () = 0;
-
-    unsigned m_nFlags;
-};
-
-//////////////////////////////////////////////////////////////////////////
-// This is on-stack class that is only used to push/pop component names
-// to/from the sizer name stack.
-//
-// USAGE:
-//
-//   Create an instance of this class at the start of a function, before
-//   calling Add* methods of the sizer interface. Everything added in the
-//   function and below will be considered this component, unless
-//   explicitly set otherwise.
-//
-class CrySizerComponentNameHelper
-{
-public:
-    // pushes the component name on top of the name stack of the given sizer
-    CrySizerComponentNameHelper (ICrySizer* pSizer, const char* szComponentName, bool bSubcomponent)
-        : m_pSizer(pSizer)
-    {
-        if (bSubcomponent)
-        {
-            pSizer->PushSubcomponent (szComponentName);
-        }
-        else
-        {
-            pSizer->Push (szComponentName);
-        }
-    }
-
-    // pops the component name off top of the name stack of the sizer
-    ~CrySizerComponentNameHelper()
-    {
-        m_pSizer->Pop();
-    }
-
-protected:
-    ICrySizer* m_pSizer;
-};
-
-// use this to push (and automatically pop) the sizer component name at the beginning of the
-// getSize() function
-#define SIZER_COMPONENT_NAME(pSizerPointer, szComponentName) CrySizerComponentNameHelper AZ_JOIN(sizerHelper, __LINE__)(pSizerPointer, szComponentName, false)
-#define SIZER_SUBCOMPONENT_NAME(pSizerPointer, szComponentName) CrySizerComponentNameHelper AZ_JOIN(sizerHelper, __LINE__)(pSizerPointer, szComponentName, true)
-
-#endif // CRYINCLUDE_CRYCOMMON_CRYSIZER_H

Code/Legacy/CryCommon/Cry_Color.h

@@ -8,21 +8,12 @@
 
 
 // Description : 4D Color template.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_COLOR_H
-#define CRYINCLUDE_CRYCOMMON_CRY_COLOR_H
 #pragma once
 
 #include <platform.h>
 #include <AzCore/std/containers/array.h>
 #include "Cry_Math.h"
 
-ILINE float FClamp(float X, float Min, float Max)
-{
-    return X < Min ? Min : X < Max ? X : Max;
-}
-
 template <class T>
 struct Color_tpl;
 
@@ -54,44 +45,6 @@ struct Color_tpl
     ILINE Color_tpl(const Vec3& c, float fAlpha);
     ILINE Color_tpl(const Vec4& c);
 
-    void Clamp(float Min = 0, float Max = 1.0f)
-    {
-        r = ::FClamp(r, Min, Max);
-        g = ::FClamp(g, Min, Max);
-        b = ::FClamp(b, Min, Max);
-        a = ::FClamp(a, Min, Max);
-    }
-    void ScaleCol (float f)
-    {
-        r = static_cast<T>(r * f);
-        g = static_cast<T>(g * f);
-        b = static_cast<T>(b * f);
-    }
-
-    float Luminance() const
-    {
-        return r * 0.30f + g * 0.59f + b * 0.11f;
-    }
-
-    ILINE float Max() const
-    {
-        return max(r, max(b, g));
-    }
-
-    float NormalizeCol (ColorF& out) const
-    {
-        float max = Max();
-
-        if (max == 0)
-        {
-            return 0;
-        }
-
-        out = *this / max;
-
-        return max;
-    }
-
     ILINE Color_tpl(const Vec3& vVec)
     {
         r = (T)vVec.x;
@@ -114,20 +67,6 @@ struct Color_tpl
         a = static_cast<T>(fA);
     }
 
-    ILINE void set(T _x, T _y = 0, T _z = 0, T _w = 0)
-    {
-        r = _x;
-        g = _y;
-        b = _z;
-        a = _w;
-    }
-    ILINE void set(T _x, T _y = 0, T _z = 0)
-    {
-        r = _x;
-        g = _y;
-        b = _z;
-        a = 1;
-    }
     ILINE Color_tpl operator + () const
     {
         return *this;
@@ -227,117 +166,12 @@ struct Color_tpl
         return (r != v.r) || (g != v.g) || (b != v.b) || (a != v.a);
     }
 
-    ILINE unsigned char pack_rgb332() const;
-    ILINE unsigned short pack_argb4444() const;
-    ILINE unsigned short pack_rgb555() const;
-    ILINE unsigned short pack_rgb565() const;
-    ILINE unsigned int pack_bgr888() const;
-    ILINE unsigned int pack_rgb888() const;
     ILINE unsigned int pack_abgr8888() const;
     ILINE unsigned int pack_argb8888() const;
-    inline Vec4 toVec4() const { return Vec4(r, g, b, a); }
     inline Vec3 toVec3() const { return Vec3(r, g, b); }
-    inline void toFloat4(f32* out) const;
-
-    inline void toHSV(f32& h, f32& s, f32& v) const;
-    inline void fromHSV(f32 h, f32 s, f32 v);
 
     inline void clamp(T bottom = 0.0f, T top = 1.0f);
 
-    inline void maximum(const Color_tpl<T>& ca, const Color_tpl<T>& cb);
-    inline void minimum(const Color_tpl<T>& ca, const Color_tpl<T>& cb);
-    inline void abs();
-
-    inline void adjust_contrast(T c);
-    inline void adjust_saturation(T s);
-    inline void adjust_luminance(float newLum);
-
-    inline void lerpFloat(const Color_tpl<T>& ca, const Color_tpl<T>& cb, float s);
-    inline void negative(const Color_tpl<T>& c);
-    inline void grey(const Color_tpl<T>& c);
-
-    // helper function - maybe we can improve the integration
-    static inline uint32 ComputeAvgCol_Fast(const uint32 dwCol0, const uint32 dwCol1)
-    {
-        uint32 dwHalfCol0 = (dwCol0 / 2) & 0x7f7f7f7f;            // each component /2
-        uint32 dwHalfCol1 = (dwCol1 / 2) & 0x7f7f7f7f;            // each component /2
-
-        return dwHalfCol0 + dwHalfCol1;
-    }
-
-    // mCIE: adjusted to compensate problems of DXT compression (extra bit in green channel causes green/purple artifacts)
-    // explained in CryEngine wiki: ColorSpaces
-    Color_tpl<T> RGB2mCIE() const
-    {
-        Color_tpl<T> in = *this;
-
-        // to get grey chrominance for dark colors
-        in.r += 0.000001f;
-        in.g += 0.000001f;
-        in.b += 0.000001f;
-
-        float RGBSum = in.r + in.g + in.b;
-
-        float fInv = 1.0f / RGBSum;
-
-        float RNorm = 3 * 10.0f / 31.0f * in.r * fInv;
-        float GNorm = 3 * 21.0f / 63.0f * in.g * fInv;
-        float Scale = RGBSum / 3.0f;
-
-        // test grey
-        //  out.r = 10.0f/31.0f;        // 1/3 = 10/30      Red range     0..30, 31 unused
-        //  out.g = 21.0f/63.0f;        // 1/3 = 21/63      Green range   0..63
-
-        RNorm = max(0.0f, min(1.0f, RNorm));
-        GNorm = max(0.0f, min(1.0f, GNorm));
-
-        return Color_tpl<T>(RNorm, GNorm, Scale);
-    }
-
-    // mCIE: adjusted to compensate problems of DXT compression (extra bit in green channel causes green/purple artefacts)
-    // explained in CryEngine wiki: ColorSpaces
-    Color_tpl<T> mCIE2RGB() const
-    {
-        Color_tpl<T> out = *this;
-
-        float fScale = out.b;               //                  Blue range   0..31
-
-        // test grey
-        //  out.r = 10.0f/31.0f;        // 1/3 = 10/30      Red range     0..30, 31 unused
-        //  out.g = 21.0f/63.0f;        // 1/3 = 21/63      Green range   0..63
-
-        out.r *= 31.0f / 30.0f;       //
-        out.g *= 63.0f / 63.0f;       //
-        out.b = 0.999f - out.r - out.g;
-
-        float s = 3.0f * fScale;
-
-        out.r *= s;
-        out.g *= s;
-        out.b *= s;
-
-        out.Clamp();
-
-        return out;
-    }
-
-    void rgb2srgb()
-    {
-        for (int i = 0; i < 3; i++)
-        {
-            T& c = (*this)[i];
-
-            if (c < 0.0031308f)
-            {
-                c = 12.92f * c;
-            }
-            else
-            {
-                c = 1.055f * pow(c, 1.0f / 2.4f) - 0.055f;
-            }
-        }
-    }
-
     void srgb2rgb()
     {
         for (int i = 0; i < 3; i++)
@@ -355,8 +189,6 @@ struct Color_tpl
         }
     }
 
-    void GetMemoryUsage([[maybe_unused]] class ICrySizer* pSizer) const { /*nothing*/}
-
     AZStd::array<T, 4> GetAsArray() const
     {
         AZStd::array<T, 4> primitiveArray = { { r, g, b, a } };
@@ -512,35 +344,10 @@ ILINE Color_tpl<uint8>::Color_tpl(const Vec4& c)
     a = (uint8)(c.w * 255);
 }
 
-template<>
-inline void Color_tpl<uint8>::toFloat4(f32* out) const
-{
-    out[0] = r / 255.0f;
-    out[1] = g / 255.0f;
-    out[2] = b / 255.0f;
-    out[3] = a / 255.0f;
-}
-
-template<>
-inline void Color_tpl<f32>::toFloat4(f32* out) const
-{
-    out[0] = r;
-    out[1] = g;
-    out[2] = b;
-    out[3] = a;
-}
-
 //////////////////////////////////////////////////////////////////////////////////////////////
 // functions implementation
 ///////////////////////////////////////////////
 
-///////////////////////////////////////////////
-/*template <class T>
-inline Color_tpl<T>::Color_tpl(const T *p_elts)
-{
-r = p_elts[0]; g = p_elts[1]; b = p_elts[2]; a = p_elts[3];
-}*/
-
 ///////////////////////////////////////////////
 ///////////////////////////////////////////////
 template <class T>
@@ -549,178 +356,6 @@ ILINE Color_tpl<T> operator * (T s, const Color_tpl<T>& v)
     return Color_tpl<T>(v.r * s, v.g * s, v.b * s, v.a * s);
 }
 
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned char Color_tpl<T>::pack_rgb332() const
-{
-    unsigned char cr;
-    unsigned char cg;
-    unsigned char cb;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned char)r;
-        cg = (unsigned char)g;
-        cb = (unsigned char)b;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned char)(r * 255.0f);
-        cg = (unsigned char)(g * 255.0f);
-        cb = (unsigned char)(b * 255.0f);
-    }
-    return ((cr >> 5) << 5) | ((cg >> 5) << 2) | (cb >> 5);
-}
-
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned short Color_tpl<T>::pack_argb4444() const
-{
-    unsigned char cr;
-    unsigned char cg;
-    unsigned char cb;
-    unsigned char ca;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned char)r;
-        cg = (unsigned char)g;
-        cb = (unsigned char)b;
-        ca = (unsigned char)a;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-        ca = (unsigned short)(a) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned char)(r * 255.0f);
-        cg = (unsigned char)(g * 255.0f);
-        cb = (unsigned char)(b * 255.0f);
-        ca = (unsigned char)(a * 255.0f);
-    }
-    return ((ca >> 4) << 12) | ((cr >> 4) << 8) | ((cg >> 4) << 4) | (cb >> 4);
-}
-
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned short Color_tpl<T>::pack_rgb555() const
-{
-    unsigned char cr;
-    unsigned char cg;
-    unsigned char cb;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned char)r;
-        cg = (unsigned char)g;
-        cb = (unsigned char)b;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned char)(r * 255.0f);
-        cg = (unsigned char)(g * 255.0f);
-        cb = (unsigned char)(b * 255.0f);
-    }
-    return ((cr >> 3) << 10) | ((cg >> 3) << 5) | (cb >> 3);
-}
-
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned short Color_tpl<T>::pack_rgb565() const
-{
-    unsigned short cr;
-    unsigned short cg;
-    unsigned short cb;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned short)r;
-        cg = (unsigned short)g;
-        cb = (unsigned short)b;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned short)(r * 255.0f);
-        cg = (unsigned short)(g * 255.0f);
-        cb = (unsigned short)(b * 255.0f);
-    }
-    return ((cr >> 3) << 11) |  ((cg >> 2) << 5) | (cb >> 3);
-}
-
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned int Color_tpl<T>::pack_bgr888() const
-{
-    unsigned char cr;
-    unsigned char cg;
-    unsigned char cb;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned char)r;
-        cg = (unsigned char)g;
-        cb = (unsigned char)b;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned char)(r * 255.0f);
-        cg = (unsigned char)(g * 255.0f);
-        cb = (unsigned char)(b * 255.0f);
-    }
-    return (cb << 16) | (cg << 8) | cr;
-}
-
-///////////////////////////////////////////////
-template <class T>
-ILINE unsigned int Color_tpl<T>::pack_rgb888() const
-{
-    unsigned char cr;
-    unsigned char cg;
-    unsigned char cb;
-    if constexpr (sizeof(r) == 1) // char and unsigned char
-    {
-        cr = (unsigned char)r;
-        cg = (unsigned char)g;
-        cb = (unsigned char)b;
-    }
-    else if constexpr (sizeof(r) == 2) // short and unsigned short
-    {
-        cr = (unsigned short)(r) >> 8;
-        cg = (unsigned short)(g) >> 8;
-        cb = (unsigned short)(b) >> 8;
-    }
-    else // float or double
-    {
-        cr = (unsigned char)(r * 255.0f);
-        cg = (unsigned char)(g * 255.0f);
-        cb = (unsigned char)(b * 255.0f);
-    }
-    return (cr << 16) | (cg << 8) | cb;
-}
-
 ///////////////////////////////////////////////
 template <class T>
 ILINE unsigned int Color_tpl<T>::pack_abgr8888() const
@@ -786,211 +421,6 @@ ILINE unsigned int Color_tpl<T>::pack_argb8888() const
     return (ca << 24) | (cr << 16) | (cg << 8) | cb;
 }
 
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::toHSV(f32& h, f32& s, f32& v) const
-{
-    f32 red, green, blue;
-    if constexpr (sizeof(this->r) == 1) // 8bit integer
-    {
-        red = this->r * (1.0f / f32(0xff));
-        green = this->g * (1.0f / f32(0xff));
-        blue = this->b * (1.0f / f32(0xff));
-    }
-    else if constexpr (sizeof(this->r) == 2) // 16bit integer
-    {
-        red = this->r * (1.0f / f32(0xffff));
-        green = this->g * (1.0f / f32(0xffff));
-        blue = this->b * (1.0f / f32(0xffff));
-    }
-    else // floating point
-    {
-        red = this->r;
-        green = this->g;
-        blue = this->b;
-    }
-
-    if ((blue > green) && (blue > red))
-    {
-        if (!::iszero(v = blue))
-        {
-            const f32 min = red < green ? red : green;
-            const f32 delta = v - min;
-            if (!::iszero(delta))
-            {
-                s = delta / v;
-                h = (240.0f / 360.0f) + (red - green) / delta * (60.0f / 360.0f);
-            }
-            else
-            {
-                s = 0.0f;
-                h = (240.0f / 360.0f) + (red - green) * (60.0f / 360.0f);
-            }
-            if (h < 0.0f)
-            {
-                h += 1.0f;
-            }
-        }
-        else
-        {
-            s = 0.0f;
-            h = 0.0f;
-        }
-    }
-    else if (green > red)
-    {
-        if (!::iszero(v = green))
-        {
-            const f32 min = red < blue ? red : blue;
-            const f32 delta = v - min;
-            if (!::iszero(delta))
-            {
-                s = delta / v;
-                h = (120.0f / 360.0f) + (blue - red) / delta * (60.0f / 360.0f);
-            }
-            else
-            {
-                s = 0.0f;
-                h = (120.0f / 360.0f) + (blue - red) * (60.0f / 360.0f);
-            }
-            if (h < 0.0f)
-            {
-                h += 1.0f;
-            }
-        }
-        else
-        {
-            s = 0.0f;
-            h = 0.0f;
-        }
-    }
-    else
-    {
-        if (!::iszero(v = red))
-        {
-            const f32 min = green < blue ? green : blue;
-            const f32 delta = v - min;
-            if (!::iszero(delta))
-            {
-                s = delta / v;
-                h = (green - blue) / delta * (60.0f / 360.0f);
-            }
-            else
-            {
-                s = 0.0f;
-                h = (green - blue) * (60.0f / 360.0f);
-            }
-            if (h < 0.0f)
-            {
-                h += 1.0f;
-            }
-        }
-        else
-        {
-            s = 0.0f;
-            h = 0.0f;
-        }
-    }
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::fromHSV(f32 h, f32 s, f32 v)
-{
-    f32 red, green, blue;
-    if (::iszero(v))
-    {
-        red = 0.0f;
-        green = 0.0f;
-        blue = 0.0f;
-    }
-    else if (::iszero(s))
-    {
-        red = v;
-        green = v;
-        blue = v;
-    }
-    else
-    {
-        const f32 hi = h * 6.0f;
-        const int32 i = (int32)::floor(hi);
-        const f32 f = hi - i;
-
-        const f32 v0 = v * (1.0f - s);
-        const f32 v1 = v * (1.0f - s * f);
-        const f32 v2 = v * (1.0f - s * (1.0f - f));
-
-        switch (i)
-        {
-        case 0:
-            red = v;
-            green = v2;
-            blue = v0;
-            break;
-        case 1:
-            red = v1;
-            green = v;
-            blue = v0;
-            break;
-        case 2:
-            red = v0;
-            green = v;
-            blue = v2;
-            break;
-        case 3:
-            red = v0;
-            green = v1;
-            blue = v;
-            break;
-        case 4:
-            red = v2;
-            green = v0;
-            blue = v;
-            break;
-        case 5:
-            red = v;
-            green = v0;
-            blue = v1;
-            break;
-
-        case 6:
-            red = v;
-            green = v2;
-            blue = v0;
-            break;
-        case -1:
-            red = v;
-            green = v0;
-            blue = v1;
-            break;
-        default:
-            red = 0.0f;
-            green = 0.0f;
-            blue = 0.0f;
-            break;
-        }
-    }
-
-    if constexpr (sizeof(this->r) == 1) // 8bit integer
-    {
-        this->r = red * f32(0xff);
-        this->g = green * f32(0xff);
-        this->b = blue * f32(0xff);
-    }
-    else if constexpr (sizeof(this->r) == 2) // 16bit integer
-    {
-        this->r = red * f32(0xffff);
-        this->g = green * f32(0xffff);
-        this->b = blue * f32(0xffff);
-    }
-    else // floating point
-    {
-        this->r = red;
-        this->g = green;
-        this->b = blue;
-    }
-}
-
 ///////////////////////////////////////////////
 template <class T>
 inline void Color_tpl<T>::clamp(T bottom, T top)
@@ -1001,214 +431,5 @@ inline void Color_tpl<T>::clamp(T bottom, T top)
     a = min(top, max(bottom, a));
 }
 
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::maximum(const Color_tpl<T>& ca, const Color_tpl<T>& cb)
-{
-    r = max(ca.r, cb.r);
-    g = max(ca.g, cb.g);
-    b = max(ca.b, cb.b);
-    a = max(ca.a, cb.a);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::minimum(const Color_tpl<T>& ca, const Color_tpl<T>& cb)
-{
-    r = min(ca.r, cb.r);
-    g = min(ca.g, cb.g);
-    b = min(ca.b, cb.b);
-    a = min(ca.a, cb.a);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::abs()
-{
-    r = fabs_tpl(r);
-    g = fabs_tpl(g);
-    b = fabs_tpl(b);
-    a = fabs_tpl(a);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::adjust_contrast(T c)
-{
-    r = 0.5f + c * (r - 0.5f);
-    g = 0.5f + c * (g - 0.5f);
-    b = 0.5f + c * (b - 0.5f);
-    a = 0.5f + c * (a - 0.5f);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::adjust_saturation(T s)
-{
-    // Approximate values for each component's contribution to luminance.
-    // Based upon the NTSC standard described in ITU-R Recommendation BT.709.
-    T grey = r * 0.2125f + g * 0.7154f + b * 0.0721f;
-    r = grey + s * (r - grey);
-    g = grey + s * (g - grey);
-    b = grey + s * (b - grey);
-    a = grey + s * (a - grey);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::adjust_luminance(float newLum)
-{
-    // Optimized yet equivalent version of replacing luminance in XYZ space.
-    // Color and luminance are expected to be linear.
-
-    Color_tpl<f32> colF(r, g, b, a);
-
-    float lum = colF.r * 0.212671f + colF.g * 0.715160f + colF.b * 0.072169f;
-    if (iszero(lum))
-    {
-        return;
-    }
-
-    *this = Color_tpl<T>(colF * newLum / lum);
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::lerpFloat(const Color_tpl<T>& ca, const Color_tpl<T>& cb, float s)
-{
-    r = (T)(ca.r + s * (cb.r - ca.r));
-    g = (T)(ca.g + s * (cb.g - ca.g));
-    b = (T)(ca.b + s * (cb.b - ca.b));
-    a = (T)(ca.a + s * (cb.a - ca.a));
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::negative([[maybe_unused]] const Color_tpl<T>& c)
-{
-    r = T(1.0f) - r;
-    g = T(1.0f) - g;
-    b = T(1.0f) - b;
-    a = T(1.0f) - a;
-}
-
-///////////////////////////////////////////////
-template <class T>
-inline void Color_tpl<T>::grey([[maybe_unused]] const Color_tpl<T>& c)
-{
-    T m = (r + g + b) / T(3);
-
-    r = m;
-    g = m;
-    b = m;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////
-//#define RGBA8(r,g,b,a)   (ColorB((uint8)(r),(uint8)(g),(uint8)(b),(uint8)(a)))
-#if defined(NEED_ENDIAN_SWAP)
-    #define RGBA8(a, b, g, r)     ((uint32)(((uint8)(r) | ((uint16)((uint8)(g)) << 8)) | (((uint32)(uint8)(b)) << 16)) | (((uint32)(uint8)(a)) << 24))
-#else
-    #define RGBA8(r, g, b, a)     ((uint32)(((uint8)(r) | ((uint16)((uint8)(g)) << 8)) | (((uint32)(uint8)(b)) << 16)) | (((uint32)(uint8)(a)) << 24))
-#endif
-#define Col_Black                               ColorF (0.000f, 0.000f, 0.000f) // 0xFF000000   RGB: 0, 0, 0
-#define Col_White                               ColorF (1.000f, 1.000f, 1.000f) // 0xFFFFFFFF   RGB: 255, 255, 255
-#define Col_Aquamarine                  ColorF (0.498f, 1.000f, 0.831f) // 0xFF7FFFD4   RGB: 127, 255, 212
-#define Col_Azure                               ColorF (0.000f, 0.498f, 1.000f) // 0xFF007FFF       RGB: 0, 127, 255
-#define Col_Blue                                ColorF (0.000f, 0.000f, 1.000f) // 0xFF0000FF   RGB: 0, 0, 255
-#define Col_BlueViolet                  ColorF (0.541f, 0.169f, 0.886f) // 0xFF8A2BE2   RGB: 138, 43, 226
-#define Col_Brown                               ColorF (0.647f, 0.165f, 0.165f) // 0xFFA52A2A   RGB: 165, 42, 42
-#define Col_CadetBlue                       ColorF (0.373f, 0.620f, 0.627f) // 0xFF5F9EA0   RGB: 95, 158, 160
-#define Col_Coral                               ColorF (1.000f, 0.498f, 0.314f) // 0xFFFF7F50   RGB: 255, 127, 80
-#define Col_CornflowerBlue          ColorF (0.392f, 0.584f, 0.929f) // 0xFF6495ED   RGB: 100, 149, 237
-#define Col_Cyan                                ColorF (0.000f, 1.000f, 1.000f) // 0xFF00FFFF   RGB: 0, 255, 255
-#define Col_DarkGray                        ColorF (0.663f, 0.663f, 0.663f) // 0xFFA9A9A9   RGB: 169, 169, 169
-#define Col_DarkGrey                        ColorF (0.663f, 0.663f, 0.663f) // 0xFFA9A9A9   RGB: 169, 169, 169
-#define Col_DarkGreen                       ColorF (0.000f, 0.392f, 0.000f) // 0xFF006400   RGB: 0, 100, 0
-#define Col_DarkOliveGreen          ColorF (0.333f, 0.420f, 0.184f) // 0xFF556B2F   RGB: 85, 107, 47
-#define Col_DarkOrchid                  ColorF (0.600f, 0.196f, 0.800f) // 0xFF9932CC   RGB: 153, 50, 204
-#define Col_DarkSlateBlue               ColorF (0.282f, 0.239f, 0.545f) // 0xFF483D8B   RGB: 72, 61, 139
-#define Col_DarkSlateGray               ColorF (0.184f, 0.310f, 0.310f) // 0xFF2F4F4F   RGB: 47, 79, 79
-#define Col_DarkSlateGrey               ColorF (0.184f, 0.310f, 0.310f) // 0xFF2F4F4F   RGB: 47, 79, 79
-#define Col_DarkTurquoise               ColorF (0.000f, 0.808f, 0.820f) // 0xFF00CED1       RGB: 0, 206, 209
-#define Col_DarkWood                        ColorF (0.050f, 0.010f, 0.005f) // 0xFF0D0301       RGB: 13, 3, 1
-#define Col_DeepPink                        ColorF (1.000f, 0.078f, 0.576f) // 0xFFFF1493       RGB: 255, 20, 147
-#define Col_DimGray                         ColorF (0.412f, 0.412f, 0.412f) // 0xFF696969   RGB: 105, 105, 105
-#define Col_DimGrey                         ColorF (0.412f, 0.412f, 0.412f) // 0xFF696969   RGB: 105, 105, 105
-#define Col_FireBrick                       ColorF (0.698f, 0.133f, 0.133f) // 0xFFB22222   RGB: 178, 34, 34
-#define Col_ForestGreen                 ColorF (0.133f, 0.545f, 0.133f) // 0xFF228B22   RGB: 34, 139, 34
-#define Col_Gold                                ColorF (1.000f, 0.843f, 0.000f) // 0xFFFFD700   RGB: 255, 215, 0
-#define Col_Goldenrod                       ColorF (0.855f, 0.647f, 0.125f) // 0xFFDAA520   RGB: 218, 165, 32
-#define Col_Gray                                ColorF (0.502f, 0.502f, 0.502f) // 0xFF808080   RGB: 128, 128, 128
-#define Col_Grey                                ColorF (0.502f, 0.502f, 0.502f) // 0xFF808080   RGB: 128, 128, 128
-#define Col_Green                               ColorF (0.000f, 0.502f, 0.000f) // 0xFF008000   RGB: 0, 128, 0
-#define Col_GreenYellow                 ColorF (0.678f, 1.000f, 0.184f) // 0xFFADFF2F   RGB: 173, 255, 47
-#define Col_IndianRed                       ColorF (0.804f, 0.361f, 0.361f) // 0xFFCD5C5C   RGB: 205, 92, 92
-#define Col_Khaki                               ColorF (0.941f, 0.902f, 0.549f) // 0xFFF0E68C   RGB: 240, 230, 140
-#define Col_LightBlue                       ColorF (0.678f, 0.847f, 0.902f) // 0xFFADD8E6   RGB: 173, 216, 230
-#define Col_LightGray                       ColorF (0.827f, 0.827f, 0.827f) // 0xFFD3D3D3   RGB: 211, 211, 211
-#define Col_LightGrey                       ColorF (0.827f, 0.827f, 0.827f) // 0xFFD3D3D3   RGB: 211, 211, 211
-#define Col_LightSteelBlue          ColorF (0.690f, 0.769f, 0.871f) // 0xFFB0C4DE   RGB: 176, 196, 222
-#define Col_LightWood                       ColorF (0.600f, 0.240f, 0.100f) // 0xFF993D1A       RGB: 153, 61, 26
-#define Col_Lime                                ColorF (0.000f, 1.000f, 0.000f) // 0xFF00FF00   RGB: 0, 255, 0
-#define Col_LimeGreen                       ColorF (0.196f, 0.804f, 0.196f) // 0xFF32CD32   RGB: 50, 205, 50
-#define Col_Magenta                         ColorF (1.000f, 0.000f, 1.000f) // 0xFFFF00FF   RGB: 255, 0, 255
-#define Col_Maroon                          ColorF (0.502f, 0.000f, 0.000f) // 0xFF800000   RGB: 128, 0, 0
-#define Col_MedianWood                  ColorF (0.300f, 0.120f, 0.030f) // 0xFF4D1F09       RGB: 77, 31, 9
-#define Col_MediumAquamarine        ColorF (0.400f, 0.804f, 0.667f) // 0xFF66CDAA   RGB: 102, 205, 170
-#define Col_MediumBlue                  ColorF (0.000f, 0.000f, 0.804f) // 0xFF0000CD   RGB: 0, 0, 205
-#define Col_MediumForestGreen       ColorF (0.420f, 0.557f, 0.137f) // 0xFF6B8E23       RGB: 107, 142, 35
-#define Col_MediumGoldenrod         ColorF (0.918f, 0.918f, 0.678f) // 0xFFEAEAAD       RGB: 234, 234, 173
-#define Col_MediumOrchid                ColorF (0.729f, 0.333f, 0.827f) // 0xFFBA55D3   RGB: 186, 85, 211
-#define Col_MediumSeaGreen          ColorF (0.235f, 0.702f, 0.443f) // 0xFF3CB371   RGB: 60, 179, 113
-#define Col_MediumSlateBlue         ColorF (0.482f, 0.408f, 0.933f) // 0xFF7B68EE   RGB: 123, 104, 238
-#define Col_MediumSpringGreen       ColorF (0.000f, 0.980f, 0.604f) // 0xFF00FA9A   RGB: 0, 250, 154
-#define Col_MediumTurquoise         ColorF (0.282f, 0.820f, 0.800f) // 0xFF48D1CC   RGB: 72, 209, 204
-#define Col_MediumVioletRed         ColorF (0.780f, 0.082f, 0.522f) // 0xFFC71585   RGB: 199, 21, 133
-#define Col_MidnightBlue                ColorF (0.098f, 0.098f, 0.439f) // 0xFF191970   RGB: 25, 25, 112
-#define Col_Navy                                ColorF (0.000f, 0.000f, 0.502f) // 0xFF000080   RGB: 0, 0, 128
-#define Col_NavyBlue                        ColorF (0.137f, 0.137f, 0.557f) // 0xFF23238E       RGB: 35, 35, 142
-#define Col_Orange                          ColorF (1.000f, 0.647f, 0.000f) // 0xFFFFA500   RGB: 255, 165, 0
-#define Col_OrangeRed                       ColorF (1.000f, 0.271f, 0.000f) // 0xFFFF4500   RGB: 255, 69, 0
-#define Col_Orchid                          ColorF (0.855f, 0.439f, 0.839f) // 0xFFDA70D6   RGB: 218, 112, 214
-#define Col_PaleGreen                       ColorF (0.596f, 0.984f, 0.596f) // 0xFF98FB98   RGB: 152, 251, 152
-#define Col_Pink                                ColorF (1.000f, 0.753f, 0.796f) // 0xFFFFC0CB   RGB: 255, 192, 203
-#define Col_Plum                                ColorF (0.867f, 0.627f, 0.867f) // 0xFFDDA0DD   RGB: 221, 160, 221
-#define Col_Red                                 ColorF (1.000f, 0.000f, 0.000f) // 0xFFFF0000   RGB: 255, 0, 0
-#define Col_Salmon                          ColorF (0.980f, 0.502f, 0.447f) // 0xFFFA8072   RGB: 250, 128, 114
-#define Col_SeaGreen                        ColorF (0.180f, 0.545f, 0.341f) // 0xFF2E8B57   RGB: 46, 139, 87
-#define Col_Sienna                          ColorF (0.627f, 0.322f, 0.176f) // 0xFFA0522D   RGB: 160, 82, 45
-#define Col_SkyBlue                         ColorF (0.529f, 0.808f, 0.922f) // 0xFF87CEEB   RGB: 135, 206, 235
-#define Col_SlateBlue                       ColorF (0.416f, 0.353f, 0.804f) // 0xFF6A5ACD   RGB: 106, 90, 205
-#define Col_SpringGreen                 ColorF (0.000f, 1.000f, 0.498f) // 0xFF00FF7F   RGB: 0, 255, 127
-#define Col_SteelBlue                       ColorF (0.275f, 0.510f, 0.706f) // 0xFF4682B4   RGB: 70, 130, 180
-#define Col_Tan                                 ColorF (0.824f, 0.706f, 0.549f) // 0xFFD2B48C   RGB: 210, 180, 140
-#define Col_Thistle                         ColorF (0.847f, 0.749f, 0.847f) // 0xFFD8BFD8   RGB: 216, 191, 216
-#define Col_Transparent                 ColorF (0.0f, 0.0f, 0.0f, 0.0f) // 0x00000000       RGB: 0, 0, 0
-#define Col_Turquoise                       ColorF (0.251f, 0.878f, 0.816f) // 0xFF40E0D0   RGB: 64, 224, 208
-#define Col_Violet                          ColorF (0.933f, 0.510f, 0.933f) // 0xFFEE82EE   RGB: 238, 130, 238
-#define Col_VioletRed                       ColorF (0.800f, 0.196f, 0.600f) // 0xFFCC3299       RGB: 204, 50, 153
-#define Col_Wheat                               ColorF (0.961f, 0.871f, 0.702f) // 0xFFF5DEB3   RGB: 245, 222, 179
-#define Col_Yellow                          ColorF (1.000f, 1.000f, 0.000f) // 0xFFFFFF00   RGB: 255, 255, 0
-#define Col_YellowGreen                 ColorF (0.604f, 0.804f, 0.196f) // 0xFF9ACD32   RGB: 154, 205, 50
 #define Col_TrackviewDefault    ColorF (0.187820792f, 0.187820792f, 1.0f)
-
 #define Clr_Empty                               ColorF(0.0f, 0.0f, 0.0f, 1.0f)
-#define Clr_Dark                                ColorF(0.15f, 0.15f, 0.15f, 1.0f)
-#define Clr_White                               ColorF(1.0f, 1.0f, 1.0f, 1.0f)
-#define Clr_WhiteTrans                          ColorF(1.0f, 1.0f, 1.0f, 0.0f)
-#define Clr_Full                                ColorF(1.0f, 1.0f, 1.0f, 1.0f)
-#define Clr_Neutral                             ColorF(1.0f, 1.0f, 1.0f, 1.0f)
-#define Clr_Transparent                         ColorF(0.0f, 0.0f, 0.0f, 0.0f)
-#define Clr_FrontVector                         ColorF(0.0f, 0.0f, 0.5f, 1.0f)
-#define Clr_Static                              ColorF(127.0f / 255.0f, 127.0f / 255.0f, 0.0f, 0.0f)
-#define Clr_Median                              ColorF(0.5f, 0.5f, 0.5f, 0.0f)
-#define Clr_MedianHalf                          ColorF(0.5f, 0.5f, 0.5f, 0.5f)
-#define Clr_FarPlane                            ColorF(1.0f, 0.0f, 0.0f, 0.0f)
-#define Clr_FarPlane_R                          ColorF(bReverseDepth ? 0.0f : 1.0f, 0.0f, 0.0f, 0.0f)
-#define Clr_Unknown                             ColorF(0.0f, 0.0f, 0.0f, 0.0f)
-#define Clr_Unused                              ColorF(0.0f, 0.0f, 0.0f, 0.0f)
-#define Clr_Debug                               ColorF(1.0f, 0.0f, 0.0f, 1.0f)
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_COLOR_H
-
-

Code/Legacy/CryCommon/Cry_Geo.h

@@ -8,10 +8,6 @@
 
 
 // Description : Common structures for geometry computations
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_GEO_H
-#define CRYINCLUDE_CRYCOMMON_CRY_GEO_H
 #pragma once
 
 #include "Cry_Math.h"
@@ -29,11 +25,6 @@ struct AABB;
 template <typename F>
 struct OBB_tpl;
 
-struct Sphere;
-struct AAEllipsoid;
-struct Ellipsoid;
-struct Cone;
-
 //-----------------------------------------------------
 
 
@@ -41,127 +32,12 @@ struct Cone;
 // Definitions                                                               //
 ///////////////////////////////////////////////////////////////////////////////
 
-//
-// Random geometry generation functions.
-//
-
-enum EGeomForm
-{
-    GeomForm_Vertices,
-    GeomForm_Edges,
-    GeomForm_Surface,
-    GeomForm_Volume,
-
-    MaxGeomForm
-};
-
-enum EGeomType
-{
-    GeomType_None,
-    GeomType_BoundingBox,
-    GeomType_Physics,
-    GeomType_Render,
-};
-
 struct PosNorm
 {
     Vec3    vPos;
     Vec3    vNorm;
-
-    void zero()
-    {
-        vPos.zero();
-        vNorm.zero();
-    }
-
-    // transform by matrix, etc
-    void operator <<= (Matrix34 const& mx)
-    {
-        vPos = mx * vPos;
-        vNorm = Matrix33(mx) * vNorm;
-    }
-    void operator <<= (QuatTS const& qts)
-    {
-        vPos = qts * vPos;
-        vNorm = qts.q * vNorm;
-    }
-    void operator <<= (DualQuat const& dq)
-    {
-        vPos = dq * vPos;
-        vNorm = dq.nq * vNorm;
-    }
-};
-
-struct RectF
-{
-    float   x, y, w, h;
-    RectF()
-        : x(0)
-        , y(0)
-        , w(1)
-        , h(1)
-    {
-    }
-};
-
-struct RectI
-{
-    int   x, y, w, h;
-    RectI()
-        : x(0)
-        , y(0)
-        , w(1)
-        , h(1)
-    {
-    }
-    RectI(int inX, int inY, int inW, int inH)
-        : x(inX)
-        , y(inY)
-        , w(inW)
-        , h(inH)
-    {
-    }
-    _inline void Add(RectI rcAdd)
-    {
-        int x2 = x + w;
-        int y2 = y + h;
-        int x22 = rcAdd.x + rcAdd.w;
-        int y22 = rcAdd.y + rcAdd.h;
-        x =  min(x, rcAdd.x);
-        y =  min(y, rcAdd.y);
-        x2 = max(x2, x22);
-        y2 = max(y2, y22);
-        w = x2 - x;
-        h = y2 - y;
-    }
-    _inline void Add(int inX, int inY, int inW, int inH)
-    {
-        Add(RectI(inX, inY, inW, inH));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// struct Line
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-struct Line
-{
-    Vec3 pointonline;
-    Vec3 direction; //caution: the direction is important for any intersection test
-
-    //default Line constructor (without initialisation)
-    inline Line(void) {}
-    inline Line(const Vec3& o, const Vec3& d) {  pointonline = o; direction = d; }
-    inline void operator () (const Vec3& o, const Vec3& d) {  pointonline = o; direction = d; }
-
-    ~Line(void) {};
 };
 
-
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -190,26 +66,18 @@ struct Ray
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-template <typename F>
-struct Lineseg_tpl
+struct Lineseg
 {
-    Vec3_tpl<F> start;
-    Vec3_tpl<F> end;
+    Vec3_tpl<float> start;
+    Vec3_tpl<float> end;
 
     //default Lineseg constructor (without initialisation)
-    inline Lineseg_tpl(void) {}
-    inline Lineseg_tpl(const Vec3_tpl<F>& s, const Vec3_tpl<F>& e) {  start = s; end = e; }
-    inline void operator () (const Vec3_tpl<F>& s, const Vec3_tpl<F>& e) {  start = s; end = e; }
+    inline Lineseg(void) {}
+    inline Lineseg(const Vec3_tpl<float>& s, const Vec3_tpl<float>& e) {  start = s; end = e; }
 
-    Vec3 GetPoint(F t) const {return t * end + (F(1.0) - t) * start; }
-
-    ~Lineseg_tpl(void) {};
+    ~Lineseg(void) {};
 };
 
-typedef Lineseg_tpl<float> Lineseg;
-typedef Lineseg_tpl<real> Linesegr;
-
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -240,33 +108,6 @@ struct Triangle_tpl
     }
 };
 
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// struct Cone
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-struct Cone
-{
-    Vec3 mTip;
-    Vec3 mDir;
-    Vec3 mBase;
-
-    float mHeight;
-    float mBaseRadius;
-
-    Cone() {}
-    Cone(const Vec3& tip, const Vec3& dir, float height, float baseRadius)
-        : mTip(tip)
-        , mDir(dir)
-        , mBase(tip + dir * height)
-        , mHeight(height)
-        , mBaseRadius(baseRadius) {}
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -343,12 +184,6 @@ struct AABB
     ILINE float GetRadius() const
     { return IsResetSel(0.0f, (max - min).GetLengthFloat() * 0.5f); }
 
-    ILINE float GetRadiusSqr() const
-    { return IsResetSel(0.0f, ((max - min) * 0.5f).GetLengthSquaredFloat()); }
-
-    ILINE float GetVolume() const
-    { return IsResetSel(0.0f, (max.x - min.x) * (max.y - min.y) * (max.z - min.z)); }
-
     ILINE void Add(const Vec3& v)
     {
         min.CheckMin(v);
@@ -368,133 +203,6 @@ struct AABB
         max.CheckMax(bb.max);
     }
 
-    inline void Move(const Vec3& v)
-    {
-        const float moveMult = IsResetSel(0.0f, 1.0f);
-        const Vec3 vMove = v * moveMult;
-        min += vMove;
-        max += vMove;
-    }
-
-    inline void Expand(Vec3 const& v)
-    {
-        if (!IsReset())
-        {
-            min -= v;
-            max += v;
-        }
-    }
-
-    // Augment the box on all sides by a box.
-    inline void Augment(AABB const& bb)
-    {
-        if (!IsReset() && !bb.IsReset())
-        {
-            Add(min + bb.min);
-            Add(max + bb.max);
-        }
-    }
-
-    void ClipToBox(AABB const& bb)
-    {
-        min.CheckMax(bb.min);
-        max.CheckMin(bb.max);
-    }
-
-    void ClipMoveToBox(AABB const& bb)
-    {
-        for (int a = 0; a < 3; a++)
-        {
-            if (max[a] - min[a] > bb.max[a] - bb.min[a])
-            {
-                min[a] = bb.min[a];
-                max[a] = bb.max[a];
-            }
-            else if (min[a] < bb.min[a])
-            {
-                max[a] += bb.min[a] - min[a];
-                min[a] = bb.min[a];
-            }
-            else if (max[a] > bb.max[a])
-            {
-                min[a] += bb.max[a] - max[a];
-                max[a] = bb.max[a];
-            }
-        }
-    }
-
-    //! Check if this bounding box overlap with bounding box of sphere.
-    bool IsOverlapSphereBounds(const Vec3& pos, float radius) const
-    {
-        assert(min.IsValid());
-        assert(max.IsValid());
-        assert(pos.IsValid());
-
-        if (pos.x > min.x && pos.x < max.x &&   pos.y > min.y && pos.y < max.y &&   pos.z > min.z && pos.z < max.z)
-        {
-            return true;
-        }
-
-        if (pos.x + radius < min.x)
-        {
-            return false;
-        }
-        if (pos.y + radius < min.y)
-        {
-            return false;
-        }
-        if (pos.z + radius < min.z)
-        {
-            return false;
-        }
-        if (pos.x - radius > max.x)
-        {
-            return false;
-        }
-        if (pos.y - radius > max.y)
-        {
-            return false;
-        }
-        if (pos.z - radius > max.z)
-        {
-            return false;
-        }
-        return true;
-    }
-
-    //! Check if this bounding box contain sphere within itself.
-    bool IsContainSphere(const Vec3& pos, float radius) const
-    {
-        assert(min.IsValid());
-        assert(max.IsValid());
-        assert(pos.IsValid());
-        if (pos.x - radius < min.x)
-        {
-            return false;
-        }
-        if (pos.y - radius < min.y)
-        {
-            return false;
-        }
-        if (pos.z - radius < min.z)
-        {
-            return false;
-        }
-        if (pos.x + radius > max.x)
-        {
-            return false;
-        }
-        if (pos.y + radius > max.y)
-        {
-            return false;
-        }
-        if (pos.z + radius > max.z)
-        {
-            return false;
-        }
-        return true;
-    }
-
     //! Check if this bounding box contains a point within itself.
     bool IsContainPoint(const Vec3& pos) const
     {
@@ -541,27 +249,6 @@ struct AABB
         return sqrt(GetDistanceSqr(v));
     }
 
-    bool ContainsBox(AABB const& b) const
-    {
-        assert(min.IsValid());
-        assert(max.IsValid());
-        assert(b.min.IsValid());
-        assert(b.max.IsValid());
-        return min.x <= b.min.x && min.y <= b.min.y && min.z <= b.min.z
-               && max.x >= b.max.x && max.y >= b.max.y && max.z >= b.max.z;
-    }
-
-    bool ContainsBox2D(AABB const& b) const
-    {
-        assert(min.IsValid());
-        assert(max.IsValid());
-        assert(b.min.IsValid());
-        assert(b.max.IsValid());
-        return min.x <= b.min.x && min.y <= b.min.y
-               && max.x >= b.max.x && max.y >= b.max.y;
-    }
-
-
     // Check two bounding boxes for intersection.
     inline bool IsIntersectBox(const AABB& b) const
     {
@@ -622,86 +309,6 @@ struct AABB
             max = pos + sz;
         }
     }
-    ILINE static AABB CreateTransformedAABB(const Matrix34& m34, const AABB& aabb)
-    { AABB taabb; taabb.SetTransformedAABB(m34, aabb); return taabb;     }
-
-
-
-    ILINE void SetTransformedAABB(const QuatT& qt, const AABB& aabb)
-    {
-        if (aabb.IsReset())
-        {
-            Reset();
-        }
-        else
-        {
-            Matrix33 m33 = Matrix33(qt.q);
-            m33.m00 = fabs_tpl(m33.m00);
-            m33.m01 = fabs_tpl(m33.m01);
-            m33.m02 = fabs_tpl(m33.m02);
-            m33.m10 = fabs_tpl(m33.m10);
-            m33.m11 = fabs_tpl(m33.m11);
-            m33.m12 = fabs_tpl(m33.m12);
-            m33.m20 = fabs_tpl(m33.m20);
-            m33.m21 = fabs_tpl(m33.m21);
-            m33.m22 = fabs_tpl(m33.m22);
-            Vec3 sz     =   m33 * ((aabb.max - aabb.min) * 0.5f);
-            Vec3 pos    =  qt * ((aabb.max + aabb.min) * 0.5f);
-            min = pos - sz;
-            max = pos + sz;
-        }
-    }
-    ILINE static AABB CreateTransformedAABB(const QuatT& qt, const AABB& aabb)
-    { AABB taabb; taabb.SetTransformedAABB(qt, aabb); return taabb;  }
-
-
-    //create an AABB using just the extensions of the OBB and ignore the orientation.
-    template<typename F>
-    ILINE void SetAABBfromOBB(const OBB_tpl<F>& obb)
-    { min = obb.c - obb.h; max = obb.c + obb.h; }
-    template<typename F>
-    ILINE static AABB CreateAABBfromOBB(const OBB_tpl<F>& obb)
-    {   return AABB(obb.c - obb.h, obb.c + obb.h);   }
-
-    /*!
-    * converts an OBB into an tight fitting AABB
-    *
-    * Example:
-    * AABB aabb = AABB::CreateAABBfromOBB(wposition,obb,1.0f);
-    *
-    * return values:
-    *  expanded AABB in world-space
-    */
-    template<typename F>
-    ILINE void SetAABBfromOBB(const Vec3& wpos, const OBB_tpl<F>& obb, f32 scaling = 1.0f)
-    {
-        Vec3 pos    = obb.m33 * obb.c * scaling + wpos;
-        Vec3 sz     =   obb.m33.GetFabs() * obb.h * scaling;
-        min = pos - sz;
-        max = pos + sz;
-    }
-    template<typename F>
-    ILINE static AABB CreateAABBfromOBB(const Vec3& wpos, const OBB_tpl<F>& obb, f32 scaling = 1.0f)
-    { AABB taabb; taabb.SetAABBfromOBB(wpos, obb, scaling); return taabb;     }
-
-    /* Converts a Cone into a tight fitting AABB */
-    ILINE static AABB CreateAABBfromCone(const Cone& c)
-    {
-        // Construct AABB for cone base
-        Vec3 baseX = Vec3(1.f - c.mDir.x * c.mDir.x, c.mDir.x * c.mDir.y, c.mDir.x * c.mDir.z).GetNormalized() * c.mBaseRadius;
-        Vec3 baseY = Vec3(c.mDir.y * c.mDir.x, 1.f - c.mDir.y * c.mDir.y, c.mDir.y * c.mDir.z).GetNormalized() * c.mBaseRadius;
-        Vec3 baseZ = Vec3(c.mDir.z * c.mDir.x, c.mDir.z * c.mDir.y, 1.f - c.mDir.z * c.mDir.z).GetNormalized() * c.mBaseRadius;
-
-        Vec3 aabbMax = Vec3(baseX.x, baseY.y, baseZ.z).abs();
-        Vec3 aabbMin = -aabbMax;
-
-        AABB result(aabbMin, aabbMax);
-        result.Move(c.mBase);
-
-        // add tip
-        result.Add(c.mTip);
-        return result;
-    }
 };
 
 ILINE bool IsEquivalent(const AABB& a, const AABB& b, float epsilon = VEC_EPSILON)
@@ -710,9 +317,6 @@ ILINE bool IsEquivalent(const AABB& a, const AABB& b, float epsilon = VEC_EPSILO
 }
 
 
-
-
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -752,6 +356,7 @@ struct OBB_tpl
     ~OBB_tpl(void) {};
 };
 
+typedef OBB_tpl<f32>    OBB;
 
 
 
@@ -774,392 +379,4 @@ struct Sphere
     void operator()(const Vec3& c, float r) { center = c; radius = r; }
 };
 
-struct HWVSphere
-{
-    hwvec3  center;
-    simdf       radius;
-
-    ILINE HWVSphere(const hwvec3& c, const simdf& r)
-    {
-        center = c;
-        radius = r;
-    }
-
-    ILINE HWVSphere(const ::Sphere& sp)
-    {
-        center = HWVLoadVecUnaligned(&sp.center);
-        radius = SIMDFLoadFloat(sp.radius);
-    }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// struct AAEllipsoid
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-struct AAEllipsoid
-{
-    Vec3 center;
-    Vec3 radius_vec;
-
-    //default AAEllipsoid constructor (without initialisation)
-    inline AAEllipsoid(void) {}
-    inline AAEllipsoid(const Vec3& c, const Vec3& rv) {  radius_vec = rv; center = c; }
-    inline void operator () (const Vec3& c, const Vec3& rv) {  radius_vec = rv; center = c; }
-
-    ~AAEllipsoid(void) {};
-};
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// struct Ellipsoid
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-struct Ellipsoid
-{
-    Matrix34 ExtensionPos;
-
-    //default Ellipsoid constructor (without initialisation)
-    inline Ellipsoid(void) {}
-    inline Ellipsoid(const Matrix34& ep) {  ExtensionPos = ep; }
-    inline void operator () (const Matrix34& ep) {  ExtensionPos = ep; }
-
-    ~Ellipsoid(void) {};
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// struct TRect
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-template <class Num>
-struct TRect_tpl
-{
-    typedef Vec2_tpl<Num> Vec;
-
-    Vec Min, Max;
-
-    inline TRect_tpl() {}
-    inline TRect_tpl(Num x1, Num y1, Num x2, Num y2)
-        : Min(x1, y1)
-        , Max(x2, y2) {}
-    inline TRect_tpl(const TRect_tpl<Num>& rc)
-        : Min(rc.Min)
-        , Max(rc.Max) {}
-    inline TRect_tpl(const Vec& min, const Vec& max)
-        : Min(min)
-        , Max(max) {}
-
-    inline TRect_tpl<Num> operator * (Num k) const
-    {
-        return TRect_tpl<Num>(Min.x * k, Min.y * k, Max.x * k, Max.y * k);
-    }
-    inline TRect_tpl<Num> operator / (Num k) const
-    {
-        return TRect_tpl<Num>(Min.x / k, Min.y / k, Max.x / k, Max.y / k);
-    }
-
-    inline bool IsEmpty() const { return Max.x < Min.x && Max.y < Min.y; }
-    inline TRect_tpl<Num>& SetEmpty() { Max = Vec(-1, -1); Min = Vec(0, 0); return *this; }
-
-    inline Vec GetDim() const { return Max - Min; }
-    inline Num GetWidth() const { return Max.x - Min.x; }
-    inline Num GetHeight() const { return Max.y - Min.y; }
-
-    inline bool IsEqual(const TRect_tpl<Num>& rc) const { return Min.x == rc.Min.x && Min.y == rc.Min.y && Max.x == rc.Max.x && Max.y == rc.Max.y; }
-
-    inline bool InRect(const TRect_tpl<Num>& rc) const { return rc.Min.x >= Min.x && rc.Max.x <= Max.x && rc.Min.y >= Min.y && rc.Max.y <= Max.y; }
-    inline bool InRect(Vec pt) const { return pt.x >= Min.x && pt.x <= Max.x && pt.y >= Min.y && pt.y <= Max.y; }
-    inline Vec& IntoRect(Vec& pt) const
-    {
-        if (pt.x < Min.x)
-        {
-            pt.x = Min.x;
-        }
-        else if (pt.x > Max.x)
-        {
-            pt.x = Max.x;
-        }
-        if (pt.y < Min.y)
-        {
-            pt.y = Min.y;
-        }
-        else if (pt.y > Max.y)
-        {
-            pt.y = Max.y;
-        }
-        return pt;
-    }
-
-    inline bool Intersects(const TRect_tpl<Num>& rc) const
-    {
-        return !IsEmpty() && !rc.IsEmpty() &&
-               !(Min.x > rc.Max.x || Max.x < rc.Min.x ||
-                 Min.y > rc.Max.y || Max.y < rc.Min.y);
-    }
-
-    inline TRect_tpl<Num>& DoUnite(const TRect_tpl<Num>& rc)
-    {
-        if (IsEmpty())
-        {
-            Min = rc.Min;
-            Max = rc.Max;
-            return *this;
-        }
-        if (rc.IsEmpty())
-        {
-            return *this;
-        }
-        if (Min.x > rc.Min.x)
-        {
-            Min.x = rc.Min.x;
-        }
-        if (Min.y > rc.Min.y)
-        {
-            Min.y = rc.Min.y;
-        }
-        if (Max.x < rc.Max.x)
-        {
-            Max.x = rc.Max.x;
-        }
-        if (Max.y < rc.Max.y)
-        {
-            Max.y = rc.Max.y;
-        }
-        return *this;
-    }
-
-    inline TRect_tpl<Num>& DoIntersect(const TRect_tpl<Num>& rc)
-    {
-        if (IsEmpty())
-        {
-            return *this;
-        }
-        if (rc.IsEmpty())
-        {
-            return SetEmpty();
-        }
-        if (Min.x < rc.Min.x)
-        {
-            Min.x = rc.Min.x;
-        }
-        if (Min.y < rc.Min.y)
-        {
-            Min.y = rc.Min.y;
-        }
-        if (Max.x > rc.Max.x)
-        {
-            Max.x = rc.Max.x;
-        }
-        if (Max.y > rc.Max.y)
-        {
-            Max.y = rc.Max.y;
-        }
-
-        if (Min.x == Max.x || Min.y == Max.y)
-        {
-            return SetEmpty();
-        }
-
-        return *this;
-    }
-
-    inline TRect_tpl<Num> GetSubRect(const TRect_tpl<Num>& rc) const
-    {
-        if (IsEmpty())
-        {
-            return *this;
-        }
-        if (rc.IsEmpty())
-        {
-            return rc;
-        }
-        return TRect_tpl<Num>(Min.x + rc.Min.x * GetWidth(),
-            Min.y + rc.Min.y * GetHeight(),
-            Min.x + rc.Max.x * GetWidth(),
-            Min.y + rc.Max.y * GetHeight());
-    }
-
-    inline TRect_tpl<Num> GetSubRectInv(const TRect_tpl<Num>& rcSub) const
-    {
-        if (IsEmpty())
-        {
-            return *this;
-        }
-        if (rcSub.IsEmpty())
-        {
-            return rcSub;
-        }
-        return TRect_tpl((rcSub.Min.x - Min.x) / GetWidth(),
-            (rcSub.Min.y - Min.y) / GetHeight(),
-            (rcSub.Max.x - Min.x) / GetWidth(),
-            (rcSub.Max.y - Min.y) / GetHeight());
-    }
-};
-
-typedef TRect_tpl<float> Rectf;
-typedef TRect_tpl<int> Recti;
-
 typedef Triangle_tpl<f32>   Triangle;
-typedef Triangle_tpl<f64>   Triangle_f64;
-typedef OBB_tpl<f32>    OBB;
-
-//////////////////////////////////////////////////////////////////////////
-// Manage linear and rotational 3D velocity in a class
-class Velocity3
-{
-public:
-    Vec3        vLin, vRot;
-
-    Velocity3()
-    {}
-    Velocity3(type_zero)
-        : vLin(ZERO)
-        , vRot(ZERO) {}
-    Velocity3(Vec3 const& lin)
-        : vLin(lin)
-        , vRot(ZERO) {}
-    Velocity3(Vec3 const& lin, Vec3 const& rot)
-        : vLin(lin)
-        , vRot(rot) {}
-
-    void FromDelta(QuatT const& loc0, QuatT const& loc1, float fTime)
-    {
-        float fInvT = 1.f / fTime;
-        vLin = (loc1.t - loc0.t) * fInvT;
-        vRot = Quat::log(loc1.q * loc0.q.GetInverted()) * fInvT;
-    }
-
-    Vec3 VelocityAt(Vec3 const& vPosRel) const
-    { return vLin + (vRot % vPosRel); }
-
-    void operator += (Velocity3 const& vv)
-    {
-        vLin += vv.vLin;
-        vRot += vv.vRot;
-    }
-    void operator *= (float f)
-    {
-        vLin *= f;
-        vRot *= f;
-    }
-    void Interp(Velocity3 const& vv, float f)
-    {
-        vLin += (vv.vLin - vLin) * f;
-        vRot += (vv.vRot - vRot) * f;
-    }
-};
-
-/////////////////////////////////////////////////////////////////////////
-//this is some special engine stuff, should be moved to a better location
-/////////////////////////////////////////////////////////////////////////
-
-// for bbox's checks and calculations
-#define MAX_BB  +99999.0f
-#define MIN_BB  -99999.0f
-
-//! checks if this has been set to minBB
-inline bool IsMinBB(const Vec3& v)
-{
-    if (v.x <= MIN_BB)
-    {
-        return (true);
-    }
-    if (v.y <= MIN_BB)
-    {
-        return (true);
-    }
-    if (v.z <= MIN_BB)
-    {
-        return (true);
-    }
-    return (false);
-}
-
-//! checks if this has been set to maxBB
-inline bool IsMaxBB(const Vec3& v)
-{
-    if (v.x >= MAX_BB)
-    {
-        return (true);
-    }
-    if (v.y >= MAX_BB)
-    {
-        return (true);
-    }
-    if (v.z >= MAX_BB)
-    {
-        return (true);
-    }
-    return (false);
-}
-
-inline Vec3 SetMaxBB(void) { return Vec3(MAX_BB, MAX_BB, MAX_BB); }
-inline Vec3 SetMinBB(void) { return Vec3(MIN_BB, MIN_BB, MIN_BB); }
-
-inline void AddToBounds (const Vec3& v, Vec3& mins, Vec3& maxs)
-{
-    if (v.x < mins.x)
-    {
-        mins.x = v.x;
-    }
-    if (v.x > maxs.x)
-    {
-        maxs.x = v.x;
-    }
-    if (v.y < mins.y)
-    {
-        mins.y = v.y;
-    }
-    if (v.y > maxs.y)
-    {
-        maxs.y = v.y;
-    }
-    if (v.z < mins.z)
-    {
-        mins.z = v.z;
-    }
-    if (v.z > maxs.z)
-    {
-        maxs.z = v.z;
-    }
-}
-
-
-////////////////////////////////////////////////////////////////
-//! calc the area of a polygon giving a list of vertices and normal
-inline float CalcArea(const Vec3* vertices, int numvertices, const Vec3& normal)
-{
-    Vec3 csum(0, 0, 0);
-
-    int n = numvertices;
-    for (int i = 0, j = 1; i <= n - 2; i++, j++)
-    {
-        csum.x += vertices[i].y * vertices[j].z - vertices[i].z * vertices[j].y;
-        csum.y += vertices[i].z * vertices[j].x - vertices[i].x * vertices[j].z;
-        csum.z += vertices[i].x * vertices[j].y - vertices[i].y * vertices[j].x;
-    }
-
-    csum.x += vertices[n - 1].y * vertices[0].z - vertices[n - 1].z * vertices[0].y;
-    csum.y += vertices[n - 1].z * vertices[0].x - vertices[n - 1].x * vertices[0].z;
-    csum.z += vertices[n - 1].x * vertices[0].y - vertices[n - 1].y * vertices[0].x;
-
-    float area = 0.5f * (float)fabs(normal | csum);
-    return (area);
-}
-
-
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_GEO_H

Code/Legacy/CryCommon/Cry_HWMatrix.h

@@ -1,85 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Scalar implementation of hardware vector based matrix
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_HWMATRIX_H
-#define CRYINCLUDE_CRYCOMMON_CRY_HWMATRIX_H
-#pragma once
-
-struct hwmtx33
-{
-    hwvec3 m0, m1, m2;
-};
-
-ILINE void HWMtx33LoadAligned(hwmtx33& out, const Matrix34A& inMtx)
-{
-    out.m0 = HWVLoadVecAligned(reinterpret_cast<const Vec4A*>(&inMtx.m00));
-    out.m1 = HWVLoadVecAligned(reinterpret_cast<const Vec4A*>(&inMtx.m10));
-    out.m2 = HWVLoadVecAligned(reinterpret_cast<const Vec4A*>(&inMtx.m20));
-}
-
-ILINE hwvec3 HWMtx33RotateVec(const hwmtx33& m, const hwvec3& v)
-{
-    return Vec3((m.m0[0] * v.x) + (m.m0[1] * v.y) + (m.m0[2] * v.z),
-        (m.m1[0] * v.x) + (m.m1[1] * v.y) + (m.m1[2] * v.z),
-        (m.m2[0] * v.x) + (m.m2[1] * v.y) + (m.m2[2] * v.z));
-}
-
-ILINE hwvec3 HWMtx33RotateVecOpt(const hwmtx33& m, const hwvec3& v)
-{
-    return HWMtx33RotateVec(m, v);
-}
-
-ILINE hwmtx33 HWMtx33CreateRotationV0V1(const hwvec3& v0, const hwvec3& v1)
-{
-    assert((fabs_tpl(1 - (v0 | v0))) < 0.01); //check if unit-vector
-    assert((fabs_tpl(1 - (v1 | v1))) < 0.01); //check if unit-vector
-    hwmtx33 m;
-    float dot = v0 | v1;
-    if (dot < -0.9999f)
-    {
-        Vec3 axis = v0.GetOrthogonal().GetNormalized();
-        m.m0[0] = (2.0f * axis.x * axis.x - 1);
-        m.m0[1] = (2.0f * axis.x * axis.y);
-        m.m0[2] = (2.0f * axis.x * axis.z);
-        m.m1[0] = (2.0f * axis.y * axis.x);
-        m.m1[1] = (2.0f * axis.y * axis.y - 1);
-        m.m1[2] = (2.0f * axis.y * axis.z);
-        m.m2[0] = (2.0f * axis.z * axis.x);
-        m.m2[1] = (2.0f * axis.z * axis.y);
-        m.m2[2] = (2.0f * axis.z * axis.z - 1);
-    }
-    else
-    {
-        Vec3 v = v0 % v1;
-        f32 h = 1.0f / (1.0f + dot);
-        m.m0[0] = (dot + h * v.x * v.x);
-        m.m0[1] = (h * v.x * v.y - v.z);
-        m.m0[2] = (h * v.x * v.z + v.y);
-        m.m1[0] = (h * v.x * v.y + v.z);
-        m.m1[1] = (dot + h * v.y * v.y);
-        m.m1[2] = (h * v.y * v.z - v.x);
-        m.m2[0] = (h * v.x * v.z - v.y);
-        m.m2[1] = (h * v.y * v.z + v.x);
-        m.m2[2] = (dot + h * v.z * v.z);
-    }
-
-    return m;
-}
-
-//Returns a matrix optimized for this platform's matrix ops, in this case, not doing a thing;
-ILINE hwmtx33 HWMtx33GetOptimized(const hwmtx33& m)
-{
-    return (hwmtx33)m;
-}
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_HWMATRIX_H
-

Code/Legacy/CryCommon/Cry_HWVector3.h

@@ -1,278 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description: Hardware vector class - scalar implementation
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_HWVECTOR3_H
-#define CRYINCLUDE_CRYCOMMON_CRY_HWVECTOR3_H
-#pragma once
-
-
-#define HWV_PERMUTE_0X 0
-#define HWV_PERMUTE_0Y 1
-#define HWV_PERMUTE_0Z 2
-#define HWV_PERMUTE_0W 3
-#define HWV_PERMUTE_1X 4
-#define HWV_PERMUTE_1Y 5
-#define HWV_PERMUTE_1Z 6
-#define HWV_PERMUTE_1W 7
-
-typedef Vec3 hwvec3;
-typedef Vec4 hwvec4;
-typedef float simdf;
-typedef Vec4 hwvec4fconst;
-typedef int hwvec4i[4];
-
-#define HWV3Constant(name, f0, f1, f2) const Vec3 name(f0, f1, f2)
-#define SIMDFConstant(name, f0) const simdf name = f0
-#define HWV4PermuteControl(name, i0, i1, i2, i3) static const hwvec4i name = {i0, i1, i2, i3};
-#define SIMDFAsVec3(a) (hwvec3)a
-#define HWV3AsSIMDF(a) (simdf)a.x
-
-ILINE hwvec3 HWVLoadVecUnaligned(const Vec3* pLoadFrom)
-{
-    return *pLoadFrom;
-}
-
-ILINE hwvec3 HWVLoadVecAligned(const Vec4A* pLoadFrom)
-{
-    return Vec3(pLoadFrom->x, pLoadFrom->y, pLoadFrom->z);
-}
-
-ILINE void HWVSaveVecUnaligned(Vec3* pSaveTo, const hwvec3& pLoadFrom)
-{
-    *pSaveTo = pLoadFrom;
-}
-
-ILINE void HWVSaveVecAligned(Vec4* pSaveTo, const hwvec4& pLoadFrom)
-{
-    *pSaveTo = pLoadFrom;
-}
-
-ILINE hwvec3 HWVAdd(const hwvec3& a, const hwvec3& b)
-{
-    return hwvec3(a.x + b.x, a.y + b.y, a.z + b.z);
-}
-
-ILINE hwvec3 HWVMultiply(const hwvec3& a, const hwvec3& b)
-{
-    return hwvec3(a.x * b.x, a.y * b.y, a.z * b.z);
-}
-
-ILINE hwvec3 HWVMultiplySIMDF(const hwvec3& a, const simdf& b)
-{
-    return hwvec3(a.x * b, a.y * b, a.z * b);
-}
-
-ILINE hwvec3 HWVMultiplyAdd(const hwvec3& a, const hwvec3& b, const hwvec3& c)
-{
-    return hwvec3((a.x * b.x) + c.x, (a.y * b.y) + c.y, (a.z * b.z) + c.z);
-}
-
-ILINE hwvec3 HWVMultiplySIMDFAdd(const hwvec3& a, const simdf& b, const hwvec3& c)
-{
-    return hwvec3((a.x * b) + c.x, (a.y * b) + c.y, (a.z * b) + c.z);
-}
-
-ILINE hwvec3 HWVSub(const hwvec3& a, const hwvec3& b)
-{
-    return (a - b);
-}
-
-ILINE hwvec3 HWVCross(const hwvec3& a, const hwvec3& b)
-{
-    return hwvec3((a.y * b.z) - (a.z * b.y)
-        , (a.z * b.x) - (a.x * b.z)
-        , (a.x * b.y) - (a.y * b.x));
-}
-
-ILINE simdf HWV3Dot(const hwvec3& a, const hwvec3& b)
-{
-    return (a.x * b.x) + (a.y * b.y) + (a.z * b.z);
-}
-
-ILINE hwvec3 HWVMax(const hwvec3& a, const hwvec3& b)
-{
-    return Vec3(a.x > b.x ? a.x : b.x,
-        a.y > b.y ? a.y : b.y,
-        a.z > b.z ? a.z : b.z);
-}
-
-ILINE hwvec3 HWVMin(const hwvec3& a, const hwvec3& b)
-{
-    return Vec3(a.x < b.x ? a.x : b.x,
-        a.y < b.y ? a.y : b.y,
-        a.z < b.z ? a.z : b.z);
-}
-
-ILINE hwvec3 HWVClamp(const hwvec3& a, const hwvec3& min, const hwvec3& max)
-{
-    return HWVMax(min, HWVMin(a, max));
-}
-
-ILINE hwvec3 HWV3Normalize(const hwvec3& a)
-{
-    float fInvLen = isqrt_safe_tpl((a.x * a.x) + (a.y * a.y) + (a.z * a.z));
-    return Vec3(a.x * fInvLen, a.y * fInvLen, a.z * fInvLen);
-}
-
-ILINE hwvec3 HWVGetOrthogonal(const hwvec3& a)
-{
-    hwvec3 result = a;
-
-    //int i = isneg(square(0.9f)*a.GetLengthSquared()-(a.x*a.x));
-    int i = isneg(square(0.9f) * a.GetLengthSquared() - a.x * a.x);
-    result[i] = 0;
-    result[incm3(i)] = a[decm3(i)];
-    result[decm3(i)] = -a[incm3(i)];
-    return result;
-}
-
-ILINE simdf HWV3SplatXToSIMDF(const hwvec3& a)
-{
-    return a.x;
-}
-
-ILINE simdf HWV3SplatYToSIMDF(const hwvec3& a)
-{
-    return a.y;
-}
-
-ILINE hwvec3 HWV3PermuteWord(const hwvec3& a, const hwvec3& b, const hwvec4i& p)
-{
-    hwvec3 selection[2] = {a, b};
-    float* fSelection = (float*)selection;
-    return Vec3(fSelection[p[0]], fSelection[p[1]], fSelection[p[2]]);
-}
-
-ILINE hwvec3 HWV3Zero()
-{
-    return Vec3(0.0f, 0.0f, 0.0f);
-}
-
-ILINE hwvec4 HWV4Zero()
-{
-    return Vec4(0.0f, 0.0f, 0.0f, 0.0f);
-}
-
-
-ILINE hwvec3 HWV3Negate(const hwvec3& a)
-{
-    return Vec3(-a.x, -a.y, -a.z);
-}
-
-ILINE hwvec3 HWVSelect(const hwvec3& a, const hwvec3& b, const hwvec3& control)
-{
-    return Vec3(control[0] > 0.0f ? b[0] : a[0],
-        control[1] > 0.0f ? b[1] : a[1],
-        control[2] > 0.0f ? b[2] : a[2]);
-}
-
-ILINE hwvec3 HWVSelectSIMDF(const hwvec3& a, const hwvec3& b, const bool& control)
-{
-    return control ? b : a;
-}
-
-ILINE simdf HWV3LengthSq(const hwvec3& a)
-{
-    return a.len2();
-}
-
-
-//////////////////////////////////////////////////
-//SIMDF functions for float stored in HWVEC4 data
-//////////////////////////////////////////////////
-
-ILINE simdf SIMDFLoadFloat(const float& f)
-{
-    return f;
-}
-
-ILINE void SIMDFSaveFloat(float* f, const simdf& a)
-{
-    *f = a;
-}
-
-ILINE bool SIMDFGreaterThan(const simdf& a, const simdf& b)
-{
-    return (a > b);
-}
-
-ILINE bool SIMDFLessThanEqualB(const simdf& a, const simdf& b)
-{
-    return (a <= b);
-}
-
-ILINE bool SIMDFLessThanEqual(const simdf& a, const simdf& b)
-{
-    return (a <= b);
-}
-
-ILINE bool SIMDFLessThanB(const simdf& a, const simdf& b)
-{
-    return (a < b);
-}
-
-ILINE bool SIMDFLessThan(const simdf& a, const simdf& b)
-{
-    return (a < b);
-}
-
-ILINE simdf SIMDFAdd(const simdf& a, const simdf& b)
-{
-    return a + b;
-}
-
-ILINE simdf SIMDFMult(const simdf& a, const simdf& b)
-{
-    return a * b;
-}
-
-ILINE simdf SIMDFReciprocal(const simdf& a)
-{
-    return 1.0f / a;
-}
-
-ILINE simdf SIMDFSqrt(const simdf& a)
-{
-    return sqrt_tpl(a);
-}
-
-ILINE simdf SIMDFSqrtEst(const simdf& a)
-{
-    return sqrt_tpl(a);
-}
-
-ILINE simdf SIMDFSqrtEstFast(const simdf& a)
-{
-    return sqrt_tpl(a);
-}
-
-ILINE simdf SIMDFMax(const simdf& a, const simdf& b)
-{
-    return max(a, b);
-}
-
-ILINE simdf SIMDFMin(const simdf& a, const simdf& b)
-{
-    return min(a, b);
-}
-
-ILINE simdf SIMDFClamp(const simdf& a, const simdf& min, const simdf& max)
-{
-    return clamp_tpl(a, min, max);
-}
-
-ILINE simdf SIMDFAbs(const simdf& a)
-{
-    return fabsf(a);
-}
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_HWVECTOR3_H

Code/Legacy/CryCommon/Cry_Math.h

@@ -8,8 +8,6 @@
 
 
 // Description : Common math class
-
-
 #pragma once
 
 //========================================================================================
@@ -18,7 +16,6 @@
 #include "Cry_ValidNumber.h"
 #include <CryEndian.h>  // eLittleEndian
 #include <CryHalf.inl>
-//#include <MetaUtils.h>
 #include <float.h>
 ///////////////////////////////////////////////////////////////////////////////
 // Forward declarations                                                      //
@@ -27,8 +24,7 @@ template <typename F>
 struct Vec2_tpl;
 template <typename F>
 struct Vec3_tpl;
-template <typename F>
-struct Vec4_tpl;
+struct Vec4;
 
 template <typename F>
 struct Ang3_tpl;
@@ -38,14 +34,6 @@ template <typename F>
 struct AngleAxis_tpl;
 template <typename F>
 struct Quat_tpl;
-template <typename F>
-struct QuatT_tpl;
-template <typename F>
-struct DualQuat_tpl;
-template <typename F>
-struct QuatTS_tpl;
-template <typename F>
-struct QuatTNS_tpl;
 
 template <typename F>
 struct Diag33_tpl;
@@ -94,14 +82,8 @@ const f32 gf_halfPI = f32(1.57079632679489661923132169163975144209858469968755);
 #define TANGENT30_2 0.57735026918962576450914878050196f * 2 // 2*tan(30)
 #define LN2 0.69314718055994530941723212145818f // ln(2)
 
-
-
-
-
 ILINE f32 fsel(const f32 _a, const f32 _b, const f32 _c) { return (_a < 0.0f) ? _c : _b; }
 ILINE f64 fsel(const f64 _a, const f64 _b, const f64 _c) { return (_a < 0.0f) ? _c : _b; }
-ILINE f32 fself(const f32 _a, const f32 _b, const f32 _c) { return (_a < 0.0f) ? _c : _b; }
-ILINE f32 fsels(const f32 _a, const f32 _b, const f32 _c) { return (_a < 0.0f) ? _c : _b; }
 ILINE f32 fres(const f32 _a) { return 1.f / _a; }
 template<class T>
 ILINE T isel(int c, T a, T b) {   return (c < 0) ? b : a; }
@@ -319,13 +301,6 @@ ILINE int64 pos_round(f64 f)  { return int64(f + 0.5); }
 ILINE int32 int_ceil(f32 f) {   int32 i = int32(f); return (f > f32(i)) ? i + 1 : i; }
 ILINE int64 int_ceil(f64 f) {   int64 i = int64(f); return (f > f64(i)) ? i + 1 : i; }
 
-ILINE float ufrac8_to_float(float u) { return u * (1.f / 255.f); }
-ILINE float ifrac8_to_float(float i) { return i * (1.f / 127.f); }
-ILINE uint8 float_to_ufrac8(float f) { int i = pos_round(f * 255.f);  assert(i >= 0 && i < 256);  return uint8(i); }
-ILINE int8  float_to_ifrac8(float f) { int i = int_round(f * 127.f);  assert(abs(i) <= 127);  return int8(i); }
-
-
-
 template<class F>
 ILINE F sqr(const F& op) { return op * op; }
 template<class F>
@@ -490,11 +465,8 @@ ILINE int64 iszero(long int x) {    return -(x >> 63 ^ (x - 1) >> 63); }
 #endif
 
 ILINE float if_neg_else(float test, float val_neg, float val_nonneg) {  return (float)fsel(test, val_nonneg, val_neg); }
-ILINE float if_pos_else(float test, float val_pos, float val_nonpos) {  return (float)fsel(-test, val_nonpos, val_pos); }
 template<class F>
 ILINE int32 inrange(F x, F end1, F end2) {    return isneg(fabs_tpl(end1 + end2 - x * (F)2) - fabs_tpl(end1 - end2)); }
-template<class F>
-ILINE F cond_select(int32 bFirst, F op1, F op2) {  F arg[2] = { op1, op2 };     return arg[bFirst ^ 1]; }
 
 template<class F>
 ILINE int32 idxmax3(const F* pdata)
@@ -510,56 +482,6 @@ ILINE int32 idxmax3(const Vec3_tpl<F>& vec)
     imax |= isneg(vec[imax] - vec.z) << 1;
     return imax & (2 | (imax >> 1 ^ 1));
 }
-template<class F>
-ILINE int32 idxmin3(const F* pdata)
-{
-    int32 imin = isneg(pdata[1] - pdata[0]);
-    imin |= isneg(pdata[2] - pdata[imin]) << 1;
-    return imin & (2 | (imin >> 1 ^ 1));
-}
-template<class F>
-ILINE int32 idxmin3(const Vec3_tpl<F>& vec)
-{
-    int32 imin = isneg(vec.y - vec.x);
-    imin |= isneg(vec.z - vec[imin]) << 1;
-    return imin & (2 | (imin >> 1 ^ 1));
-}
-// Approximation of exp(-x)
-ILINE float approxExp(float x) { return fres(1.f + x); }
-// Approximation of 1.f - exp(-x)
-ILINE float approxOneExp(float x) {     return x * fres(1.f + x); }
-
-
-ILINE int ilog2(uint64 x)   // if x==1<<i (i=0..63), returns i
-{
-#if defined(CRY_PLATFORM_X64)
-# if defined(AZ_RESTRICTED_PLATFORM)
-#  include AZ_RESTRICTED_FILE(Cry_Math_h)
-# endif
-# if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
-#  undef AZ_RESTRICTED_SECTION_IMPLEMENTED
-# elif defined(CRY_PLATFORM_LINUX)
-#  define HAS_BIT_SCAN_FORWARD64 0
-# else
-#  define HAS_BIT_SCAN_FORWARD64 1
-# endif
-#endif
-
-#if HAS_BIT_SCAN_FORWARD64
-    unsigned long i;
-    _BitScanForward64(&i, x);
-    return i;
-#else
-    union
-    {
-        float f;
-        uint i;
-    } u;
-    u.f = (float)x;
-    return (u.i >> 23) - 127;
-#endif
-}
-
 
 static int32 inc_mod3[] = {1, 2, 0}, dec_mod3[] = {2, 0, 1};
 #ifdef PHYSICS_EXPORTS
@@ -596,114 +518,6 @@ enum type_identity
 #include "Cry_Matrix34.h"
 #include "Cry_Matrix44.h"
 #include "Cry_Quat.h"
-#include "Cry_HWVector3.h"
-#include "Cry_HWMatrix.h"
-
-//////////////////////////////////////////////////////////////////////////
-
-/// This function relaxes a value (val) towards a desired value (to) whilst maintaining continuity
-/// of val and its rate of change (valRate). timeDelta is the time between this call and the previous one.
-/// The caller would normally keep val and valRate as working variables, and smoothTime is normally
-/// a fixed parameter. The to/timeDelta values can change.
-///
-/// Implementation details:
-///
-/// This is a critically damped spring system. A linear spring is attached between "val" and "to" that
-/// drags "val" to "to". At the same time a damper between the two removes oscillations; it's tweaked
-/// so it doesn't dampen more than necessary. In combination this gives smooth ease-in and ease-out behavior.
-///
-/// smoothTime can be interpreted in a couple of ways:
-/// - it's the "expected time to reach the target when at maximum velocity" (the target will, however, not be reached
-///   in that time because the speed will decrease the closer it gets to the target)
-/// - it's the 'lag time', how many seconds "val" lags behind "to". If your
-///   target has a certain speed, the lag distance is simply the smoothTime times that speed.
-/// - it's 2/omega, where omega is the spring's natural frequency (or less formally a measure of the spring stiffness)
-///
-/// The implementation is stable for varying timeDelta, but for performance reasons it uses a polynomial approximation
-/// to the exponential function. The approximation works well (within 0.1% of accuracy) when smoothTime > 2*deltaTime,
-/// which is usually the case. (but it might be troublesome when you want a stiff spring or have frame hikes!)
-/// The implementation handles cases where smoothTime==0 separately and reliably. In that case the target will be
-/// reached immediately, and valRate is updated appropriately.
-///
-/// Based on "Critically Damped Ease-In/Ease-Out Smoothing", Thomas Lowe, Game Programming Gems IV
-///
-
-
-template <typename T>
-ILINE void SmoothCD(
-    T& val,                 ///< in/out: value to be smoothed
-    T& valRate,             ///< in/out: rate of change of the value
-    const float timeDelta,  ///< in: time interval
-    const T& to,            ///< in: the target value
-    const float smoothTime) ///< in: timescale for smoothing
-{
-    if (smoothTime > 0.0f)
-    {
-        const float omega = 2.0f / smoothTime;
-        const float x = omega * timeDelta;
-        const float exp = 1.0f / (1.0f + x + 0.48f * x * x + 0.235f * x * x * x);
-        const T change = (val - to);
-        const T temp = (T)((valRate + change * omega) * timeDelta);
-        valRate = (T)((valRate - temp * omega) * exp);
-        val = (T)(to + (change + temp) * exp);
-    }
-    else if (timeDelta > 0.0f)
-    {
-        valRate = (T)((to - val) / timeDelta);
-        val = to;
-    }
-    else
-    {
-        val = to;
-        T zeroizeAmount = valRate;
-        valRate -= zeroizeAmount; // zero it...
-    }
-}
-
-
-template <typename T>
-ILINE void SmoothCDWithMaxRate(
-    T& val,                 ///< in/out: value to be smoothed
-    T& valRate,             ///< in/out: rate of change of the value
-    const float timeDelta,  ///< in: time interval
-    const T& to,            ///< in: the target value
-    const float smoothTime, ///< in: timescale for smoothing
-    const T& maxValRate)    ///< in: maximum allowed rate of change
-{
-    if (smoothTime > 0.0f)
-    {
-        const float omega = 2.0f / smoothTime;
-        const float x = omega * timeDelta;
-        const float exp = 1.0f / (1.0f + x + 0.48f * x * x + 0.235f * x * x * x);
-        const T unclampedChange = val - to;
-        const T maxChange = maxValRate * smoothTime;
-        const T clampedChange = clamp_tpl<T>(unclampedChange, -maxChange, maxChange);
-        const T clampedTo = val - clampedChange;
-        const T temp = (T)((valRate + clampedChange * omega) * timeDelta);
-        valRate = (T)((valRate - temp * omega) * exp);
-        val = (T)(clampedTo + (clampedChange + temp) * exp);
-    }
-    else if (timeDelta > 0.0f)
-    {
-        const T unclampedRate = (T)((to - val) / timeDelta);
-        valRate = clamp_tpl<T>(unclampedRate, -maxValRate, maxValRate);
-        val += valRate * timeDelta;
-    }
-    else
-    {
-        val = to;
-        T zeroizeAmount = valRate;
-        valRate -= zeroizeAmount; // zero it...
-    }
-}
-
-// Smoothes linear blending into cubic (b-spline) with 0-derivatives
-// near 0 and 1
-inline f32 SmoothBlendValue (const f32 fBlend)
-{
-    const f32 fBlendAdj = fBlend - 0.5f;
-    return (f32)fsel(-fBlend, 0.f, fsel(fBlend - 1.f, 1.f, 0.5f - 2.f * (fBlendAdj * fBlendAdj * fBlendAdj) + 1.5f * fBlendAdj));
-}
 
 // function for safe comparsion of floating point  values
 ILINE bool fcmp(f32 fA, f32 fB, f32 fEpsilon = FLT_EPSILON)

Code/Legacy/CryCommon/Cry_Matrix33.h

@@ -8,10 +8,6 @@
 
 
 // Description : Common matrix class
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_MATRIX33_H
-#define CRYINCLUDE_CRYCOMMON_CRY_MATRIX33_H
 #pragma once
 
 
@@ -64,7 +60,6 @@ struct Matrix33_tpl
 #else
     ILINE Matrix33_tpl(){};
 #endif
-
     //set matrix to Identity
     ILINE Matrix33_tpl(type_identity)
     {
@@ -78,21 +73,6 @@ struct Matrix33_tpl
         m21 = 0;
         m22 = 1;
     }
-    //set matrix to Zero
-    ILINE Matrix33_tpl(type_zero)
-    {
-        m00 = 0;
-        m01 = 0;
-        m02 = 0;
-        m10 = 0;
-        m11 = 0;
-        m12 = 0;
-        m20 = 0;
-        m21 = 0;
-        m22 = 0;
-    }
-
-
     //ASSIGNMENT OPERATOR of identical Matrix33 types.
     //The assignment operator has precedence over assignment constructor
     //Matrix33 m; m=m33;
@@ -118,7 +98,7 @@ struct Matrix33_tpl
 
     //CONSTRUCTOR for identical float-types. It initializes a Matrix33 with 9 floats.
     //Matrix33(0,1,2, 3,4,5, 6,7,8);
-    explicit ILINE Matrix33_tpl<F>(F x00, F x01, F x02, F x10, F x11, F x12, F x20, F x21, F x22)
+    explicit ILINE Matrix33_tpl(F x00, F x01, F x02, F x10, F x11, F x12, F x20, F x21, F x22)
     {
         m00 = x00;
         m01 = x01;
@@ -130,26 +110,11 @@ struct Matrix33_tpl
         m21 = x21;
         m22 = x22;
     }
-    //CONSTRUCTOR for different float-types. It initializes a Matrix33 with 9 floats.
-    //Matrix33(0.0,1.0,2.0, 3.0,4.0,5.0, 6.0,7.0,8.0);
-    template<class F1>
-    explicit ILINE Matrix33_tpl<F>(F1 x00, F1 x01, F1 x02, F1 x10, F1 x11, F1 x12, F1 x20, F1 x21, F1 x22)
-    {
-        m00 = F(x00);
-        m01 = F(x01);
-        m02 = F(x02);
-        m10 = F(x10);
-        m11 = F(x11);
-        m12 = F(x12);
-        m20 = F(x20);
-        m21 = F(x21);
-        m22 = F(x22);
-    }
 
 
     //CONSTRUCTOR for identical float-types. It initializes a Matrix33 with 3 vectors stored in the columns.
     //Matrix33(v0,v1,v2);
-    explicit ILINE Matrix33_tpl<F>(const Vec3_tpl<F>&vx, const Vec3_tpl<F>&vy, const Vec3_tpl<F>&vz)
+    explicit ILINE Matrix33_tpl(const Vec3_tpl<F>&vx, const Vec3_tpl<F>&vy, const Vec3_tpl<F>&vz)
     {
         m00 = vx.x;
         m01 = vy.x;
@@ -164,7 +129,7 @@ struct Matrix33_tpl
     //CONSTRUCTOR for different float-types. It initializes a Matrix33 with 3 vectors stored in the columns and converts between floats/doubles.
     //Matrix33r(v0,v1,v2);
     template<class F1>
-    explicit ILINE Matrix33_tpl<F>(const Vec3_tpl<F1>&vx, const Vec3_tpl<F1>&vy, const Vec3_tpl<F1>&vz)
+    explicit ILINE Matrix33_tpl(const Vec3_tpl<F1>&vx, const Vec3_tpl<F1>&vy, const Vec3_tpl<F1>&vz)
     {
         m00 = F(vx.x);
         m01 = F(vy.x);
@@ -209,8 +174,6 @@ struct Matrix33_tpl
         m22 = F(m.m22);
     }
 
-
-
     //CONSTRUCTOR for identical float-types. It converts a Matrix34 into a Matrix33.
     //Needs to be 'explicit' because we loose the translation vector in the conversion process
     //Matrix33(m34);
@@ -245,9 +208,6 @@ struct Matrix33_tpl
         m22 = F(m.m22);
     }
 
-
-
-
     //CONSTRUCTOR for identical float-types. It converts a Matrix44 into a Matrix33.
     //Needs to be 'explicit' because we loose the translation vector and the 3rd row in the conversion process
     //Matrix33(m44);
@@ -356,26 +316,6 @@ struct Matrix33_tpl
         SetRotationXYZ(Ang3_tpl<F>(F(ang.x), F(ang.y), F(ang.z)));
     }
 
-
-
-
-    //Bracket OPERATOR: initializes a Matrix33 with 9 floats.
-    //Matrix33 m; m(0,1,2, 3,4,5, 6,7,8);
-    ILINE void operator () (F x00, F x01, F x02, F x10, F x11, F x12, F x20, F x21, F x22)
-    {
-        m00 = x00;
-        m01 = x01;
-        m02 = x02;
-        m10 = x10;
-        m11 = x11;
-        m12 = x12;
-        m20 = x20;
-        m21 = x21;
-        m22 = x22;
-        assert(IsValid());
-    }
-
-
     //---------------------------------------------------------------------------------------
 
     ILINE void SetIdentity(void)
@@ -391,27 +331,6 @@ struct Matrix33_tpl
         m22 = 1;
     }
 
-    ILINE static Matrix33_tpl<F> CreateIdentity()
-    {
-        Matrix33_tpl<F> m33;
-        m33.SetIdentity();
-        return m33;
-    }
-
-    ILINE void SetZero()
-    {
-        m00 = 0;
-        m01 = 0;
-        m02 = 0;
-        m10 = 0;
-        m11 = 0;
-        m12 = 0;
-        m20 = 0;
-        m21 = 0;
-        m22 = 0;
-    }
-
-
     /*!
     *  Create a rotation matrix around an arbitrary axis (Eulers Theorem).
     *  The axis is specified as a normalized Vec3. The angle is assumed to be in radians.
@@ -597,7 +516,7 @@ struct Matrix33_tpl
         F dot = v0 | v1;
         if (dot < F(-0.9999f))
         {
-            Vec3d axis = v0.GetOrthogonal().GetNormalized();
+            Vec3_tpl<F> axis = v0.GetOrthogonal().GetNormalized();
             m00 = F(2 * axis.x * axis.x - 1);
             m01 = F(2 * axis.x * axis.y);
             m02 = F(2 * axis.x * axis.z);
@@ -723,28 +642,6 @@ struct Matrix33_tpl
         return m33;
     }
 
-
-    //! calculate 2 vector that form a orthogonal base with a given input vector (by M.M.)
-    //! /param invDirection input direction (has to be normalized)
-    //! /param outvA first output vector that is perpendicular to the input direction
-    //! /param outvB second output vector that is perpendicular the input vector and the first output vector
-    ILINE static Matrix33_tpl<F> CreateOrthogonalBase(const Vec3& invDirection)
-    {
-        Vec3 outvA;
-        if (invDirection.z < -0.5f || invDirection.z > 0.5f)
-        {
-            outvA = Vec3(invDirection.z, invDirection.y, -invDirection.x);
-        }
-        else
-        {
-            outvA = Vec3(invDirection.y, -invDirection.x, invDirection.z);
-        }
-        Vec3 outvB = (invDirection % outvA).GetNormalized();
-        outvA = (invDirection % outvB).GetNormalized();
-        return CreateFromVectors(invDirection, outvA, outvB);
-    }
-
-
     //////////////////////////////////////////////////////////////////////////
     ILINE static Matrix33_tpl<F> CreateOrientation(const Vec3_tpl<F>& dir, const Vec3_tpl<F>& up, float rollAngle)
     {
@@ -779,77 +676,6 @@ struct Matrix33_tpl
         return tm;
     }
 
-
-    /*!
-    *  Direct-Matrix-Slerp: for the sake of completeness, I have included the following expression
-    *  for Spherical-Linear-Interpolation without using quaternions. This is much faster then converting
-    *  both matrices into quaternions in order to do a quaternion slerp and then converting the slerped
-    *  quaternion back into a matrix.
-    *  This is a high-precision calculation. Given two orthonormal 3x3 matrices this function calculates
-    *  the shortest possible interpolation-path between the two rotations. The interpolation curve forms
-    *  a great arc on the rotation sphere (geodesic). Not only does Slerp follow a great arc it follows
-    *  the shortest great arc.  Furthermore Slerp has constant angular velocity. All in all Slerp is the
-    *  optimal interpolation curve between two rotations.
-    *
-    *  STABILITY PROBLEM: There are two singularities at angle=0 and angle=PI. At 0 the interpolation-axis
-    *  is arbitrary, which means any axis will produce the same result because we have no rotation. Thats
-    *  why I'm using (1,0,0). At PI the rotations point away from each other and the interpolation-axis
-    *  is unpredictable. In this case I'm also using the axis (1,0,0). If the angle is ~0 or ~PI, then we
-    *  have to normalize a very small vector and this can cause numerical instability. The quaternion-slerp
-    *  has exactly the same problems.
-    *                                                                                                  Ivo
-    *  Example:
-    *       Matrix33 slerp=Matrix33::CreateSlerp( m,n,0.333f );
-    */
-    ILINE void SetSlerp(const Matrix33_tpl<F>& m, const Matrix33_tpl<F>& n, F t)
-    {
-        assert(m.IsValid());
-        assert(n.IsValid());
-        //calculate delta-rotation between m and n (=39 flops)
-        Matrix33_tpl<F> d, i;
-        d.m00 = m.m00 * n.m00 + m.m10 * n.m10 + m.m20 * n.m20;
-        d.m01 = m.m00 * n.m01 + m.m10 * n.m11 + m.m20 * n.m21;
-        d.m02 = m.m00 * n.m02 + m.m10 * n.m12 + m.m20 * n.m22;
-        d.m10 = m.m01 * n.m00 + m.m11 * n.m10 + m.m21 * n.m20;
-        d.m11 = m.m01 * n.m01 + m.m11 * n.m11 + m.m21 * n.m21;
-        d.m12 = m.m01 * n.m02 + m.m11 * n.m12 + m.m21 * n.m22;
-        d.m20 = d.m01 * d.m12 - d.m02 * d.m11;
-        d.m21 = d.m02 * d.m10 - d.m00 * d.m12;
-        d.m22 = d.m00 * d.m11 - d.m01 * d.m10;
-        assert(d.IsOrthonormalRH(0.0001f));
-
-        Vec3_tpl<F> axis(d.m21 - d.m12, d.m02 - d.m20, d.m10 - d.m01);
-        F l = sqrt(axis | axis);
-        if (l > F(0.00001))
-        {
-            axis /= l;
-        }
-        else
-        {
-            axis(1, 0, 0);
-        }
-        i.SetRotationAA(acos(clamp_tpl((d.m00 + d.m11 + d.m22 - 1) * 0.5f, F(-1), F(+1))) * t, axis); //angle interpolation and calculation of new delta-matrix (=26 flops)
-
-        //final concatenation (=39 flops)
-        m00 = F(m.m00 * i.m00 + m.m01 * i.m10 + m.m02 * i.m20);
-        m01 = F(m.m00 * i.m01 + m.m01 * i.m11 + m.m02 * i.m21);
-        m02 = F(m.m00 * i.m02 + m.m01 * i.m12 + m.m02 * i.m22);
-        m10 = F(m.m10 * i.m00 + m.m11 * i.m10 + m.m12 * i.m20);
-        m11 = F(m.m10 * i.m01 + m.m11 * i.m11 + m.m12 * i.m21);
-        m12 = F(m.m10 * i.m02 + m.m11 * i.m12 + m.m12 * i.m22);
-        m20 = m01 * m12 - m02 * m11;
-        m21 = m02 * m10 - m00 * m12;
-        m22 = m00 * m11 - m01 * m10;
-        assert(this->IsOrthonormalRH(0.0001f));
-    }
-    ILINE static Matrix33_tpl<F> CreateSlerp(const Matrix33_tpl<F> m, const Matrix33_tpl<F> n, F t)
-    {
-        Matrix33_tpl<F> m33;
-        m33.SetSlerp(m, n, t);
-        return m33;
-    }
-
-
     ILINE void SetScale(const Vec3_tpl<F>& s)
     {
         m00 = s.x;
@@ -880,9 +706,6 @@ struct Matrix33_tpl
     }
     ILINE static Matrix33_tpl<F> CreateFromVectors(const Vec3_tpl<F>& vx, const Vec3_tpl<F>& vy, const Vec3_tpl<F>& vz) { Matrix33_tpl<F> dst; dst.SetFromVectors(vx, vy, vz); return dst;  }
 
-
-
-
     ILINE void Transpose()   // in-place transposition
     {
         F t;
@@ -896,56 +719,6 @@ struct Matrix33_tpl
         m12 = m21;
         m21 = t;
     }
-    ILINE Matrix33_tpl<F> GetTransposed() const
-    {
-        Matrix33_tpl<F> dst;
-        dst.m00 = m00;
-        dst.m01 = m10;
-        dst.m02 = m20;
-        dst.m10 = m01;
-        dst.m11 = m11;
-        dst.m12 = m21;
-        dst.m20 = m02;
-        dst.m21 = m12;
-        dst.m22 = m22;
-        return dst;
-    }
-    ILINE Matrix33_tpl<F> T() const { return GetTransposed(); }
-
-    ILINE Matrix33_tpl& Fabs()
-    {
-        m00 = fabs_tpl(m00);
-        m01 = fabs_tpl(m01);
-        m02 = fabs_tpl(m02);
-        m10 = fabs_tpl(m10);
-        m11 = fabs_tpl(m11);
-        m12 = fabs_tpl(m12);
-        m20 = fabs_tpl(m20);
-        m21 = fabs_tpl(m21);
-        m22 = fabs_tpl(m22);
-        return *this;
-    }
-    ILINE Matrix33_tpl<F> GetFabs() const { Matrix33_tpl<F> m = *this; m.Fabs();  return m;   }
-
-
-    ILINE void Adjoint(void)
-    {
-        //rescue members
-        Matrix33_tpl<F> m = *this;
-        //calculate the adjoint-matrix
-        m00 = m.m11 * m.m22 - m.m12 * m.m21;
-        m01 = m.m12 * m.m20 - m.m10 * m.m22;
-        m02 = m.m10 * m.m21 - m.m11 * m.m20;
-        m10 = m.m21 * m.m02 - m.m22 * m.m01;
-        m11 = m.m22 * m.m00 - m.m20 * m.m02;
-        m12 = m.m20 * m.m01 - m.m21 * m.m00;
-        m20 = m.m01 * m.m12 - m.m02 * m.m11;
-        m21 = m.m02 * m.m10 - m.m00 * m.m12;
-        m22 = m.m00 * m.m11 - m.m01 * m.m10;
-    }
-    ILINE Matrix33_tpl<F> GetAdjoint() const {  Matrix33_tpl<F> dst = *this; dst.Adjoint(); return dst;   }
-
-
 
     /*!
     *
@@ -1201,8 +974,6 @@ struct Matrix33_tpl
 ///////////////////////////////////////////////////////////////////////////////
 
 typedef Matrix33_tpl<f32>  Matrix33;  //always 32 bit
-typedef Matrix33_tpl<f64>  Matrix33d; //always 64 bit
-typedef Matrix33_tpl<real> Matrix33r; //variable float precision. depending on the target system it can be between 32, 64 or 80 bit
 
 //----------------------------------------------------------------------------------
 //----------------------------------------------------------------------------------
@@ -1360,9 +1131,6 @@ ILINE Matrix33_tpl<F1>& operator+=(Matrix33_tpl<F1>& l, const Matrix33_tpl<F2>&
     return l;
 }
 
-
-
-
 template<class F1, class F2>
 ILINE Matrix33_tpl<F1> operator - (const Matrix33_tpl<F1>& l, const Matrix33_tpl<F2>& r)
 {
@@ -1397,9 +1165,6 @@ ILINE Matrix33_tpl<F1>& operator-=(Matrix33_tpl<F1>& l, const Matrix33_tpl<F2>&
     return l;
 }
 
-
-
-
 template<class F>
 ILINE Matrix33_tpl<F> operator*(const Matrix33_tpl<F>& m, F op)
 {
@@ -1462,37 +1227,3 @@ ILINE Vec2_tpl<F1> operator*(const Vec2_tpl<F1>& v, const Matrix33_tpl<F2>& m)
     assert(v.IsValid());
     return Vec2_tpl<F1>(v.x * m.m00 + v.y * m.m10, v.x * m.m01 + v.y * m.m11);
 }
-
-template<class F1>
-ILINE Matrix33_tpl<F1>& crossproduct_matrix(const Vec3_tpl<F1>& v, Matrix33_tpl<F1>& m)
-{
-    m.m00 = 0;
-    m.m01 = -v.z;
-    m.m02 = v.y;
-    m.m10 = v.z;
-    m.m11 = 0;
-    m.m12 = -v.x;
-    m.m20 = -v.y;
-    m.m21 = v.x;
-    m.m22 = 0;
-    return m;
-}
-
-template<class F1>
-ILINE Matrix33_tpl<F1>& dotproduct_matrix(const Vec3_tpl<F1>& v, const Vec3_tpl<F1>& op, Matrix33_tpl<F1>& m)
-{
-    m.m00 = v.x * op.x;
-    m.m10 = v.y * op.x;
-    m.m20 = v.z * op.x;
-    m.m01 = v.x * op.y;
-    m.m11 = v.y * op.y;
-    m.m21 = v.z * op.y;
-    m.m02 = v.x * op.z;
-    m.m12 = v.y * op.z;
-    m.m22 = v.z * op.z;
-    return m;
-}
-
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_MATRIX33_H
-

Code/Legacy/CryCommon/Cry_Matrix34.h

@@ -8,16 +8,8 @@
 
 
 // Description : Common matrix class
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_MATRIX34_H
-#define CRYINCLUDE_CRYCOMMON_CRY_MATRIX34_H
 #pragma once
 
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -347,220 +339,6 @@ struct Matrix34_tpl
         *this = Matrix33_tpl<F>(q);
     }
 
-
-
-    //CONSTRUCTOR for identical float-types. It converts a QuatT into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    explicit ILINE Matrix34_tpl<F>(const QuatT_tpl<F> &q)
-    {
-        *this = Matrix34_tpl<F>(Matrix33_tpl<F>(q.q), q.t);
-    }
-    //CONSTRUCTOR for different float-types. It converts a QuatT into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    template<class F1>
-    ILINE explicit Matrix34_tpl(const QuatT_tpl<F1> q)
-    {
-        *this = Matrix34_tpl<F>(Matrix33_tpl<F1>(q.q), q.t);
-    }
-
-
-
-
-    //CONSTRUCTOR for identical float-types. It converts a QuatTS into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    explicit ILINE Matrix34_tpl<F>(const QuatTS_tpl<F> &q)
-    {
-        assert(q.q.IsValid());
-        Vec3_tpl<F> v2 = q.q.v + q.q.v;
-        F xx = 1 - v2.x * q.q.v.x;
-        F yy = v2.y * q.q.v.y;
-        F xw = v2.x * q.q.w;
-        F xy = v2.y * q.q.v.x;
-        F yz = v2.z * q.q.v.y;
-        F yw = v2.y * q.q.w;
-        F xz = v2.z * q.q.v.x;
-        F zz = v2.z * q.q.v.z;
-        F zw = v2.z * q.q.w;
-        m00 = (1 - yy - zz) * q.s;
-        m01 = (xy - zw) * q.s;
-        m02 = (xz + yw) * q.s;
-        m03 = q.t.x;
-        m10 = (xy + zw) * q.s;
-        m11 = (xx - zz) * q.s;
-        m12 = (yz - xw) * q.s;
-        m13 = q.t.y;
-        m20 = (xz - yw) * q.s;
-        m21 = (yz + xw) * q.s;
-        m22 = (xx - yy) * q.s;
-        m23 = q.t.z;
-    }
-    //CONSTRUCTOR for different float-types. It converts a QuatTS into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    template<class F1>
-    ILINE explicit Matrix34_tpl<F>(const QuatTS_tpl<F1> &q)
-    {
-        assert(q.q.IsValid());
-        Vec3_tpl<F1> v2 = q.q.v + q.q.v;
-        F1 xx = 1 - v2.x * q.q.v.x;
-        F1 yy = v2.y * q.q.v.y;
-        F1 xw = v2.x * q.q.w;
-        F1 xy = v2.y * q.q.v.x;
-        F1 yz = v2.z * q.q.v.y;
-        F1 yw = v2.y * q.q.w;
-        F1 xz = v2.z * q.q.v.x;
-        F1 zz = v2.z * q.q.v.z;
-        F1 zw = v2.z * q.q.w;
-        m00 = F((1 - yy - zz) * q.s);
-        m01 = F((xy - zw) * q.s);
-        m02 = F((xz + yw) * q.s);
-        m03 = F(q.t.x);
-        m10 = F((xy + zw) * q.s);
-        m11 = F((xx - zz) * q.s);
-        m12 = F((yz - xw) * q.s);
-        m13 = F(q.t.y);
-        m20 = F((xz - yw) * q.s);
-        m21 = F((yz + xw) * q.s);
-        m22 = F((xx - yy) * q.s);
-        m23 = F(q.t.z);
-    }
-
-
-
-
-    //CONSTRUCTOR for identical float-types. It converts a QuatTNS into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    explicit ILINE Matrix34_tpl<F>(const QuatTNS_tpl<F> &q)
-    {
-        assert(q.q.IsValid());
-        Vec3_tpl<F> v2 = q.q.v + q.q.v;
-        F xx = 1 - v2.x * q.q.v.x;
-        F yy = v2.y * q.q.v.y;
-        F xw = v2.x * q.q.w;
-        F xy = v2.y * q.q.v.x;
-        F yz = v2.z * q.q.v.y;
-        F yw = v2.y * q.q.w;
-        F xz = v2.z * q.q.v.x;
-        F zz = v2.z * q.q.v.z;
-        F zw = v2.z * q.q.w;
-        m00 = (1 - yy - zz) * q.s.x;
-        m01 = (xy - zw) * q.s.y;
-        m02 = (xz + yw) * q.s.z;
-        m03 = q.t.x;
-        m10 = (xy + zw) * q.s.x;
-        m11 = (xx - zz) * q.s.y;
-        m12 = (yz - xw) * q.s.z;
-        m13 = q.t.y;
-        m20 = (xz - yw) * q.s.x;
-        m21 = (yz + xw) * q.s.y;
-        m22 = (xx - yy) * q.s.z;
-        m23 = q.t.z;
-    }
-    //CONSTRUCTOR for different float-types. It converts a QuatTNS into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    template<class F1>
-    ILINE explicit Matrix34_tpl<F>(const QuatTNS_tpl<F1> &q)
-    {
-        assert(q.q.IsValid());
-        Vec3_tpl<F1> v2 = q.q.v + q.q.v;
-        F1 xx = 1 - v2.x * q.q.v.x;
-        F1 yy = v2.y * q.q.v.y;
-        F1 xw = v2.x * q.q.w;
-        F1 xy = v2.y * q.q.v.x;
-        F1 yz = v2.z * q.q.v.y;
-        F1 yw = v2.y * q.q.w;
-        F1 xz = v2.z * q.q.v.x;
-        F1 zz = v2.z * q.q.v.z;
-        F1 zw = v2.z * q.q.w;
-        m00 = F((1 - yy - zz) * q.s.x);
-        m01 = F((xy - zw) * q.s.y);
-        m02 = F((xz + yw) * q.s.z);
-        m03 = F(q.t.x);
-        m10 = F((xy + zw) * q.s.x);
-        m11 = F((xx - zz) * q.s.y);
-        m12 = F((yz - xw) * q.s.z);
-        m13 = F(q.t.y);
-        m20 = F((xz - yw) * q.s.x);
-        m21 = F((yz + xw) * q.s.y);
-        m22 = F((xx - yy) * q.s.z);
-        m23 = F(q.t.z);
-    }
-
-
-
-
-    //CONSTRUCTOR for identical float-types. It converts a DualQuat into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    ILINE explicit Matrix34_tpl<F>(const DualQuat_tpl<F> &q)
-    {
-        assert((fabs_tpl(1 - (q.nq | q.nq))) < 0.01); //check if unit-quaternion
-        Vec3_tpl<F>  t = (q.nq.w * q.dq.v - q.dq.w * q.nq.v + q.nq.v % q.dq.v); //perfect for HLSL
-        Vec3_tpl<F> v2 = q.nq.v + q.nq.v;
-        F xx = 1 - v2.x * q.nq.v.x;
-        F yy = v2.y * q.nq.v.y;
-        F xw = v2.x * q.nq.w;
-        F xy = v2.y * q.nq.v.x;
-        F yz = v2.z * q.nq.v.y;
-        F yw = v2.y * q.nq.w;
-        F xz = v2.z * q.nq.v.x;
-        F zz = v2.z * q.nq.v.z;
-        F zw = v2.z * q.nq.w;
-        m00 = 1 - yy - zz;
-        m01 = xy - zw;
-        m02 = xz + yw;
-        m03 = t.x + t.x;
-        m10 = xy + zw;
-        m11 = xx - zz;
-        m12 = yz - xw;
-        m13 = t.y + t.y;
-        m20 = xz - yw;
-        m21 = yz + xw;
-        m22 = xx - yy;
-        m23 = t.z + t.z;
-    }
-    //CONSTRUCTOR for different float-types. It converts a DualQuat into a Matrix34.
-    //Needs to be 'explicit' because we loose float-precision in the conversion process
-    //Matrix34(QuatT);
-    template<class F1>
-    ILINE explicit Matrix34_tpl<F>(const DualQuat_tpl<F1> &q)
-    {
-        assert((fabs_tpl(1 - (q.nq | q.nq))) < 0.01); //check if unit-quaternion
-        Vec3_tpl<F1>  t = (q.nq.w * q.dq.v - q.dq.w * q.nq.v + q.nq.v % q.dq.v); //perfect for HLSL
-        Vec3_tpl<F1> v2 = q.nq.v + q.nq.v;
-        F1 xx = 1 - v2.x * q.nq.v.x;
-        F1 yy = v2.y * q.nq.v.y;
-        F1 xw = v2.x * q.nq.w;
-        F1 xy = v2.y * q.nq.v.x;
-        F1 yz = v2.z * q.nq.v.y;
-        F1 yw = v2.y * q.nq.w;
-        F1 xz = v2.z * q.nq.v.x;
-        F1 zz = v2.z * q.nq.v.z;
-        F1 zw = v2.z * q.nq.w;
-        m00 = F(1 - yy - zz);
-        m01 = F(xy - zw);
-        m02 = F(xz + yw);
-        m03 = F(t.x + t.x);
-        m10 = F(xy + zw);
-        m11 = F(xx - zz);
-        m12 = F(yz - xw);
-        m13 = F(t.y + t.y);
-        m20 = F(xz - yw);
-        m21 = F(yz + xw);
-        m22 = F(xx - yy);
-        m23 = F(t.z + t.z);
-    }
-
-
-
-
-
-
     //apply scaling to the columns of the matrix.
     ILINE void ScaleColumn(const Vec3_tpl<F>& s)
     {
@@ -580,7 +358,7 @@ struct Matrix34_tpl
     *  Initializes the Matrix34 with the identity.
     *
     */
-    void SetIdentity(void)
+    void SetIdentity()
     {
         m00 = 1.0f;
         m01 = 0.0f;
@@ -596,58 +374,12 @@ struct Matrix34_tpl
         m23 = 0.0f;
     }
 
-    ILINE static Matrix34_tpl<F> CreateIdentity(void)
+    ILINE static Matrix34_tpl<F> CreateIdentity()
     {
         Matrix34_tpl<F> m;
         m.SetIdentity();
         return m;
     }
-
-    ILINE bool IsIdentity() const
-    {
-        return 0 == (fabs_tpl((F)1 - m00) + fabs_tpl(m01) + fabs_tpl(m02) + fabs_tpl(m03) + fabs_tpl(m10) + fabs_tpl((F)1 - m11) + fabs_tpl(m12) + fabs_tpl(m13) + fabs_tpl(m20) + fabs_tpl(m21) + fabs_tpl((F)1 - m22)) + fabs_tpl(m23);
-    }
-
-    ILINE int IsZero() const
-    {
-        return 0 == (fabs_tpl(m00) + fabs_tpl(m01) + fabs_tpl(m02) + fabs_tpl(m03) + fabs_tpl(m10) + fabs_tpl(m11) + fabs_tpl(m12) + fabs_tpl(m13) + fabs_tpl(m20) + fabs_tpl(m21) + fabs_tpl(m22)) + fabs_tpl(m23);
-    }
-
-    /*!
-    *  Create a rotation matrix around an arbitrary axis (Eulers Theorem).
-    *  The axis is specified as an normalized Vec3. The angle is assumed to be in radians.
-    *  This function also assumes a translation-vector and stores it in the right column.
-    *
-    *  Example:
-    *       Matrix34 m34;
-    *       Vec3 axis=GetNormalized( Vec3(-1.0f,-0.3f,0.0f) );
-    *       m34.SetRotationAA( 3.14314f, axis, Vec3(5,5,5) );
-    */
-    ILINE void SetRotationAA(const F rad, const Vec3_tpl<F>& axis, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        *this = Matrix33_tpl<F>::CreateRotationAA(rad, axis);
-        this->SetTranslation(t);
-    }
-    ILINE static Matrix34_tpl<F> CreateRotationAA(const F rad, const Vec3_tpl<F>& axis, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        Matrix34_tpl<F> m34;
-        m34.SetRotationAA(rad, axis, t);
-        return m34;
-    }
-
-    ILINE void SetRotationAA(const Vec3_tpl<F>& rot, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        *this = Matrix33_tpl<F>::CreateRotationAA(rot);
-        this->SetTranslation(t);
-    }
-    ILINE static Matrix34_tpl<F> CreateRotationAA(const Vec3_tpl<F>& rot, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        Matrix34_tpl<F> m34;
-        m34.SetRotationAA(rot, t);
-        return m34;
-    }
-
-
     /*!
     * Create rotation-matrix about X axis using an angle.
     * The angle is assumed to be in radians.
@@ -690,28 +422,6 @@ struct Matrix34_tpl
         return m34;
     }
 
-    /*!
-    * Create rotation-matrix about Z axis using an angle.
-    * The angle is assumed to be in radians.
-    * The translation-vector is set to zero.
-    *
-    *  Example:
-    *       Matrix34 m34;
-    *       m34.SetRotationZ(0.5f);
-    */
-    ILINE void SetRotationZ(const f32 rad, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        *this = Matrix33_tpl<F>::CreateRotationZ(rad);
-        this->SetTranslation(t);
-    }
-    ILINE static Matrix34_tpl<F> CreateRotationZ(const f32 rad, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        Matrix34_tpl<F> m34;
-        m34.SetRotationZ(rad, t);
-        return m34;
-    }
-
-
     /*!
     *
     * Convert three Euler angle to mat33 (rotation order:XYZ)
@@ -742,22 +452,6 @@ struct Matrix34_tpl
     }
 
 
-    ILINE void SetRotationAA(F c, F s, Vec3_tpl<F> axis, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        assert(axis.IsValid());
-        assert(t.IsValid());
-        *this = Matrix33_tpl<F>::CreateRotationAA(c, s, axis);
-        m03 = t.x;
-        m13 = t.y;
-        m23 = t.z;
-    }
-    ILINE static Matrix34_tpl<F> CreateRotationAA(F c, F s, Vec3_tpl<F> axis, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        Matrix34_tpl<F> m34;
-        m34.SetRotationAA(c, s, axis, t);
-        return m34;
-    }
-
     ILINE void SetTranslationMat(const Vec3_tpl<F>& v)
     {
         m00 = 1.0f;
@@ -804,25 +498,6 @@ struct Matrix34_tpl
         return m;
     }
 
-    void InvertFast()
-    { // in-place transposition
-        assert(IsOrthonormal());
-        F t;
-        Vec3 v(m03, m13, m23);
-        t = m01;
-        m01 = m10;
-        m10 = t;
-        m03 = -v.x * m00 - v.y * m01 - v.z * m20;
-        t = m02;
-        m02 = m20;
-        m20 = t;
-        m13 = -v.x * m10 - v.y * m11 - v.z * m21;
-        t = m12;
-        m12 = m21;
-        m21 = t;
-        m23 = -v.x * m20 - v.y * m21 - v.z * m22;
-    }
-
     Matrix34_tpl<F> GetInvertedFast() const
     {
         assert(IsOrthonormal());
@@ -875,14 +550,6 @@ struct Matrix34_tpl
         m22 = z.z;
     }
 
-
-    //determinant is ambiguous: only the upper-left-submatrix's determinant is calculated
-    ILINE f32 Determinant() const
-    {
-        return (m00 * m11 * m22) + (m01 * m12 * m20) + (m02 * m10 * m21) - (m02 * m11 * m20) - (m00 * m12 * m21) - (m01 * m10 * m22);
-    }
-
-
     //--------------------------------------------------------------------------------
     //----                  helper functions to access matrix-members     ------------
     //--------------------------------------------------------------------------------
@@ -896,10 +563,8 @@ struct Matrix34_tpl
     ILINE void SetRow(int i, const Vec3_tpl<F>& v)  {   assert(i < 3);    F* p = (F*)(&m00);    p[0 + 4 * i] = v.x;   p[1 + 4 * i] = v.y;   p[2 + 4 * i] = v.z;       }
 
     ILINE const Vec3_tpl<F>& GetRow(int i) const    {   assert(i < 3); return *(const Vec3_tpl<F>*)(&m00 + 4 * i);  }
-    ILINE const Vec4_tpl<F>& GetRow4(int i) const   {   assert(i < 3); return *(const Vec4_tpl<F>*)(&m00 + 4 * i);  }
+    ILINE const Vec4& GetRow4(int i) const   {   assert(i < 3); return *(const Vec4*)(&m00 + 4 * i);  }
 
-    ILINE void SetColumn(int i, const Vec3_tpl<F>& v)   {   assert(i < 4);    F* p = (F*)(&m00);    p[i + 4 * 0] = v.x;   p[i + 4 * 1] = v.y;   p[i + 4 * 2] = v.z;       }
-    ILINE Vec3_tpl<F> GetColumn(int i) const    {   assert(i < 4);    F* p = (F*)(&m00);    return Vec3(p[i + 4 * 0], p[i + 4 * 1], p[i + 4 * 2]);    }
     ILINE Vec3_tpl<F> GetColumn0() const    { return Vec3_tpl<F>(m00, m10, m20);  }
     ILINE Vec3_tpl<F> GetColumn1() const    { return Vec3_tpl<F>(m01, m11, m21);  }
     ILINE Vec3_tpl<F> GetColumn2() const    { return Vec3_tpl<F>(m02, m12, m22);  }
@@ -908,8 +573,6 @@ struct Matrix34_tpl
 
     ILINE void SetTranslation(const Vec3_tpl<F>& t) { m03 = t.x;    m13 = t.y; m23 = t.z;   }
     ILINE Vec3_tpl<F> GetTranslation() const { return Vec3_tpl<F>(m03, m13, m23); }
-    ILINE void ScaleTranslation (F s)                       {   m03 *= s;     m13 *= s;     m23 *= s;     }
-    ILINE Matrix34_tpl<F> AddTranslation(const Vec3_tpl<F>& t)    {   m03 += t.x;   m13 += t.y;   m23 += t.z;   return *this; }
 
     ILINE void SetRotation33(const Matrix33_tpl<F>& m33)
     {
@@ -924,43 +587,6 @@ struct Matrix34_tpl
         m22 = m33.m22;
     }
 
-    ILINE void GetRotation33(Matrix33_tpl<F>& m33) const
-    {
-        m33.m00 = m00;
-        m33.m01 = m01;
-        m33.m02 = m02;
-        m33.m10 = m10;
-        m33.m11 = m11;
-        m33.m12 = m12;
-        m33.m20 = m20;
-        m33.m21 = m21;
-        m33.m22 = m22;
-    }
-
-    //check if we have an orthonormal-base (general case, works even with reflection matrices)
-    int IsOrthonormal(F threshold = 0.001) const
-    {
-        f32 d0 = fabs_tpl(GetColumn0() | GetColumn1());
-        if  (d0 > threshold)
-        {
-            return 0;
-        }
-        f32 d1 = fabs_tpl(GetColumn0() | GetColumn2());
-        if  (d1 > threshold)
-        {
-            return 0;
-        }
-        f32 d2 = fabs_tpl(GetColumn1() | GetColumn2());
-        if  (d2 > threshold)
-        {
-            return 0;
-        }
-        int a = (fabs_tpl(1 - (GetColumn0() | GetColumn0()))) < threshold;
-        int b = (fabs_tpl(1 - (GetColumn1() | GetColumn1()))) < threshold;
-        int c = (fabs_tpl(1 - (GetColumn2() | GetColumn2()))) < threshold;
-        return a & b & c;
-    }
-
     //check if we have an orthonormal-base (assuming we are using a right-handed coordinate system)
     int IsOrthonormalRH(F threshold = 0.001) const
     {
@@ -978,68 +604,6 @@ struct Matrix34_tpl
             );
     }
 
-    bool IsValid() const
-    {
-        if (!NumberValid(m00))
-        {
-            return false;
-        }
-        if (!NumberValid(m01))
-        {
-            return false;
-        }
-        if (!NumberValid(m02))
-        {
-            return false;
-        }
-        if (!NumberValid(m03))
-        {
-            return false;
-        }
-        if (!NumberValid(m10))
-        {
-            return false;
-        }
-        if (!NumberValid(m11))
-        {
-            return false;
-        }
-        if (!NumberValid(m12))
-        {
-            return false;
-        }
-        if (!NumberValid(m13))
-        {
-            return false;
-        }
-        if (!NumberValid(m20))
-        {
-            return false;
-        }
-        if (!NumberValid(m21))
-        {
-            return false;
-        }
-        if (!NumberValid(m22))
-        {
-            return false;
-        }
-        if (!NumberValid(m23))
-        {
-            return false;
-        }
-        return true;
-    }
-
-
-    bool IsDegenerate(float epsilon = FLT_EPSILON) const
-    {
-        //check the basis vectors for 0 vector
-        return GetColumn0().len2() < epsilon
-               || GetColumn1().len2() < epsilon
-               || GetColumn2().len2() < epsilon;
-    }
-
     /*!
     * Create a matrix with SCALING, ROTATION and TRANSLATION (in this order).
     *
@@ -1093,43 +657,12 @@ struct Matrix34_tpl
     *  Example 1:
     *       Matrix m34;
     *       m34.SetScale( Vec3(0.5f, 1.0f, 2.0f) );
-    *  Example 2:
-    *       Matrix34 m34 = Matrix34::CreateScale( Vec3(0.5f, 1.0f, 2.0f) );
     */
     ILINE void SetScale(const Vec3_tpl<F>& s, const Vec3_tpl<F>& t = Vec3(ZERO))
     {
         *this = Matrix33::CreateScale(s);
         this->SetTranslation(t);
     }
-    ILINE static Matrix34_tpl<F> CreateScale(const Vec3_tpl<F>& s, const Vec3_tpl<F>& t = Vec3(ZERO))
-    {
-        Matrix34_tpl<F> m34;
-        m34.SetScale(s, t);
-        return m34;
-    }
-
-
-    ILINE Matrix44_tpl<F> GetTransposed() const
-    {
-        Matrix44_tpl<F> tmp;
-        tmp.m00 = m00;
-        tmp.m01 = m10;
-        tmp.m02 = m20;
-        tmp.m03 = 0;
-        tmp.m10 = m01;
-        tmp.m11 = m11;
-        tmp.m12 = m21;
-        tmp.m13 = 0;
-        tmp.m20 = m02;
-        tmp.m21 = m12;
-        tmp.m22 = m22;
-        tmp.m23 = 0;
-        tmp.m30 = m03;
-        tmp.m31 = m13;
-        tmp.m32 = m23;
-        tmp.m33 = 1;
-        return tmp;
-    }
 
     /*!
     * calculate a real inversion of a Matrix34
@@ -1141,7 +674,7 @@ struct Matrix34_tpl
     *  Example 2:
     *   Matrix34 im34 = m34.GetInverted();
     */
-    void Invert(void)
+    void Invert()
     {
         //rescue members
         Matrix34_tpl<F> m = *this;
@@ -1182,37 +715,6 @@ struct Matrix34_tpl
         dst.Invert();
         return dst;
     }
-
-    /*!
-    *  Name:             ReflectMat34
-    *  Description:      reflect a rotation matrix with respect to a plane.
-    *
-    *  Example:
-    *       Vec3 normal( 0.0f,-1.0f, 0.0f);
-    *       Vec3 pos(0,1000,0);
-    *       Matrix34 m34=CreateReflectionMat( pos, normal );
-    */
-    ILINE static Matrix34_tpl<F> CreateReflectionMat (const Vec3_tpl<F>& p, const Vec3_tpl<F>& n)
-    {
-        Matrix34_tpl<F> m;
-        F vxy   = -2.0f * n.x * n.y;
-        F vxz   = -2.0f * n.x * n.z;
-        F vyz   = -2.0f * n.y * n.z;
-        F pdotn = 2.0f * (p | n);
-        m.m00 = 1.0f - 2.0f * n.x * n.x;
-        m.m01 = vxy;
-        m.m02 = vxz;
-        m.m03 = pdotn * n.x;
-        m.m10 = vxy;
-        m.m11 = 1.0f - 2.0f * n.y * n.y;
-        m.m12 = vyz;
-        m.m13 = pdotn * n.y;
-        m.m20 = vxz;
-        m.m21 = vyz;
-        m.m22 = 1.0f - 2.0f * n.z * n.z;
-        m.m23 = pdotn * n.z;
-        return m;
-    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1220,8 +722,6 @@ struct Matrix34_tpl
 ///////////////////////////////////////////////////////////////////////////////
 
 typedef Matrix34_tpl<f32>  Matrix34; //always 32 bit
-typedef Matrix34_tpl<f64>  Matrix34d;//always 64 bit
-typedef Matrix34_tpl<real> Matrix34r;//variable float precision. depending on the target system it can be between 32, 64 or bit
 #if AZ_COMPILER_MSVC
     typedef __declspec(align(16)) Matrix34_tpl<f32> Matrix34A;
 #elif AZ_COMPILER_CLANG
@@ -1423,6 +923,3 @@ ILINE Matrix44_tpl<F> operator * (const Matrix34_tpl<F>& l, const Matrix44_tpl<F
     m.m33 = r.m33;
     return m;
 }
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_MATRIX34_H
-

Code/Legacy/CryCommon/Cry_Matrix44.h

@@ -568,12 +568,12 @@ struct Matrix44_tpl
     ILINE F& operator () (uint32 i, uint32 j)   {   assert ((i < 4) && (j < 4));    F* p_data = (F*)(&m00);       return p_data[i * 4 + j];   }
 
     ILINE void SetRow(int i, const Vec3_tpl<F>& v)  {   assert(i < 4);    F* p = (F*)(&m00);    p[0 + 4 * i] = v.x;   p[1 + 4 * i] = v.y;   p[2 + 4 * i] = v.z;       }
-    ILINE void SetRow4(int i, const Vec4_tpl<F>& v)   {   assert(i < 4);    F* p = (F*)(&m00);    p[0 + 4 * i] = v.x;   p[1 + 4 * i] = v.y;   p[2 + 4 * i] = v.z;   p[3 + 4 * i] = v.w;   }
+    ILINE void SetRow4(int i, const Vec4& v)   {   assert(i < 4);    F* p = (F*)(&m00);    p[0 + 4 * i] = v.x;   p[1 + 4 * i] = v.y;   p[2 + 4 * i] = v.z;   p[3 + 4 * i] = v.w;   }
     ILINE const Vec3_tpl<F>& GetRow(int i) const    {   assert(i < 4); return *(const Vec3_tpl<F>*)(&m00 + 4 * i);  }
 
     ILINE void SetColumn(int i, const Vec3_tpl<F>& v)   {   assert(i < 4);    F* p = (F*)(&m00);    p[i + 4 * 0] = v.x;   p[i + 4 * 1] = v.y;   p[i + 4 * 2] = v.z;       }
     ILINE Vec3_tpl<F> GetColumn(int i) const    {   assert(i < 4);    F* p = (F*)(&m00);    return Vec3(p[i + 4 * 0], p[i + 4 * 1], p[i + 4 * 2]);    }
-    ILINE Vec4_tpl<F> GetColumn4(int i) const {   assert(i < 4);    F* p = (F*)(&m00);    return Vec4(p[i + 4 * 0], p[i + 4 * 1], p[i + 4 * 2], p[i + 4 * 3]);   }
+    ILINE Vec4 GetColumn4(int i) const {   assert(i < 4);    F* p = (F*)(&m00);    return Vec4(p[i + 4 * 0], p[i + 4 * 1], p[i + 4 * 2], p[i + 4 * 3]);   }
 
     ILINE Vec3 GetTranslation() const { return Vec3(m03, m13, m23);   }
     ILINE void SetTranslation(const Vec3& t)  {   m03 = t.x; m13 = t.y; m23 = t.z; }
@@ -792,24 +792,24 @@ ILINE Matrix44_tpl<F1> operator * (const Matrix44_tpl<F1>& l, const Matrix44_tpl
 }
 
 //post-multiply
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator*(const Matrix44_tpl<F2>& m, const Vec4_tpl<F1>& v)
+template<class F2>
+ILINE Vec4 operator*(const Matrix44_tpl<F2>& m, const Vec4& v)
 {
     assert(m.IsValid());
     assert(v.IsValid());
-    return Vec4_tpl<F1>(v.x * m.m00 + v.y * m.m01 + v.z * m.m02 + v.w * m.m03,
+    return Vec4(v.x * m.m00 + v.y * m.m01 + v.z * m.m02 + v.w * m.m03,
         v.x * m.m10 + v.y * m.m11 + v.z * m.m12 + v.w * m.m13,
         v.x * m.m20 + v.y * m.m21 + v.z * m.m22 + v.w * m.m23,
         v.x * m.m30 + v.y * m.m31 + v.z * m.m32 + v.w * m.m33);
 }
 
 //pre-multiply
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator*(const Vec4_tpl<F1>& v, const Matrix44_tpl<F2>& m)
+template<class F2>
+ILINE Vec4 operator*(const Vec4& v, const Matrix44_tpl<F2>& m)
 {
     assert(m.IsValid());
     assert(v.IsValid());
-    return Vec4_tpl<F1>(v.x * m.m00 + v.y * m.m10 + v.z * m.m20 + v.w * m.m30,
+    return Vec4(v.x * m.m00 + v.y * m.m10 + v.z * m.m20 + v.w * m.m30,
         v.x * m.m01 + v.y * m.m11 + v.z * m.m21 + v.w * m.m31,
         v.x * m.m02 + v.y * m.m12 + v.z * m.m22 + v.w * m.m32,
         v.x * m.m03 + v.y * m.m13 + v.z * m.m23 + v.w * m.m33);

Code/Legacy/CryCommon/Cry_Quat.h

@@ -8,10 +8,6 @@
 
 
 // Description : Common quaternion class
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_CRY_QUAT_H
-#define CRYINCLUDE_CRYCOMMON_CRY_QUAT_H
 #pragma once
 
 #include <AzCore/Math/Quaternion.h>
@@ -751,41 +747,6 @@ struct Quat_tpl
         return d;
     }
 
-
-    /*!
-    * linear-interpolation between quaternions (nlerp)
-    * in this case we convert the t-value into a 1d cubic spline to get closer to Slerp
-    *
-    * Example:
-    *  Quat result,p,q;
-    *  result.SetNlerpCubic( p, q, 0.5f );
-    */
-    ILINE void SetNlerpCubic(const Quat_tpl<F>& p, const Quat_tpl<F>& tq, F t)
-    {
-        Quat_tpl<F> q = tq;
-        assert((fabs_tpl(1 - (p | p))) < 0.001); //check if unit-quaternion
-        assert((fabs_tpl(1 - (q | q))) < 0.001); //check if unit-quaternion
-        F cosine = (p | q);
-        if (cosine < 0)
-        {
-            q = -q;
-        }
-        F k = (1 - fabs_tpl(cosine)) * F(0.4669269);
-        F s = 2 * k * t * t * t - 3 * k * t * t + (1 + k) * t;
-        v.x = p.v.x * (1.0f - s) + q.v.x * s;
-        v.y = p.v.y * (1.0f - s) + q.v.y * s;
-        v.z = p.v.z * (1.0f - s) + q.v.z * s;
-        w       = p.w  * (1.0f - s) + q.w * s;
-        Normalize();
-    }
-    ILINE static Quat_tpl<F> CreateNlerpCubic(const Quat_tpl<F>& p, const Quat_tpl<F>& tq, F t)
-    {
-        Quat_tpl<F> d;
-        d.SetNlerpCubic(p, tq, t);
-        return d;
-    }
-
-
     /*!
     * spherical-interpolation between quaternions (geometrical slerp)
     *
@@ -836,39 +797,6 @@ struct Quat_tpl
         return d;
     }
 
-    /*!
-    * spherical-interpolation between quaternions (algebraic slerp_a)
-    * I have included this function just for the sake of completeness, because
-    * its the only useful application to check if exp & log really work.
-    * Both slerp-functions are returning the same result.
-    *
-    * Example:
-    *  Quat result,p,q;
-    *  result.SetExpSlerp( p,q,0.3345f );
-    */
-    ILINE void SetExpSlerp(const Quat_tpl<F>& p, const Quat_tpl<F>& tq, F t)
-    {
-        assert((fabs_tpl(1 - (p | p))) < 0.001); //check if unit-quaternion
-        assert((fabs_tpl(1 - (tq | tq))) < 0.001); //check if unit-quaternion
-        Quat_tpl<F> q = tq;
-        if ((p | q) < 0)
-        {
-            q = -q;
-        }
-        *this = p * exp(log(!p * q) * t);                     //algebraic slerp (1)
-        //...and some more exp-slerp-functions producing all the same result
-        //*this = exp( log (p* !q) * (1-t)) * q;    //algebraic slerp (2)
-        //*this = exp( log (q* !p) * t) * p;            //algebraic slerp (3)
-        //*this = q * exp( log (!q*p) * (1-t));     //algebraic slerp (4)
-    }
-    ILINE static Quat_tpl<F> CreateExpSlerp(const Quat_tpl<F>& p, const Quat_tpl<F>& q, F t)
-    {
-        Quat_tpl<F> d;
-        d.SetExpSlerp(p, q, t);
-        return d;
-    }
-
-
     //! squad(p,a,b,q,t) = slerp( slerp(p,q,t),slerp(a,b,t), 2(1-t)t).
     ILINE void SetSquad(const Quat_tpl<F>& p, const Quat_tpl<F>& a, const Quat_tpl<F>& b, const Quat_tpl<F>& q, F t)
     {
@@ -895,15 +823,7 @@ struct Quat_tpl
 // Typedefs                                                                  //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef MAX_API_NUM
 typedef Quat_tpl<f32>  Quat;  //always 32 bit
-typedef Quat_tpl<f64>  Quatd; //always 64 bit
-typedef Quat_tpl<real> Quatr; //variable float precision. depending on the target system it can be between 32, 64 or 80 bit
-#endif
-
-typedef Quat_tpl<f32>   CryQuat;
-typedef Quat_tpl<f32> quaternionf;
-typedef Quat_tpl<real>  quaternion;
 
 /*!
 *
@@ -964,22 +884,6 @@ ILINE void operator *= (Quat_tpl<F1>& q, const Quat_tpl<F2>& p)
     q.v = p.v * s0 + q.v * p.w + (q.v % p.v);
 }
 
-/*!
-*  Implements the multiplication operator: QuatT=Quat*Quatpos
-*
-*  AxB = operation B followed by operation A.
-*  A multiplication takes 31 muls and 27 adds (=58 float operations).
-*
-*  Example:
-*   Quat    quat        =   Quat::CreateRotationX(1.94192f);;
-*   QuatT quatpos   =   QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
-*     QuatT qp          =   quat*quatpos;
-*/
-template<class F1, class F2>
-ILINE QuatT_tpl<F1> operator * (const Quat_tpl<F1>& q, const QuatT_tpl<F2>& p)
-{
-    return QuatT_tpl<F1>(q * p.q, q * p.t);
-}
 
 
 
@@ -1154,1043 +1058,3 @@ ILINE void operator %= (Quat_tpl<F1>& q, const Quat_tpl<F2>& tp)
     }
     q = Quat_tpl<F1>(q.w + p.w, q.v + p.v);
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//----------------------------------------------------------------------
-// Quaternion with translation vector
-//----------------------------------------------------------------------
-template <typename F>
-struct QuatT_tpl
-{
-    Quat_tpl<F> q; //this is the quaternion
-    Vec3_tpl<F> t; //this is the translation vector and a scalar (for uniform scaling?)
-
-    ILINE QuatT_tpl(){}
-
-    //initialize with zeros
-    ILINE QuatT_tpl(type_zero)
-    {
-        q.w = 0, q.v.x = 0, q.v.y = 0, q.v.z = 0, t.x = 0, t.y = 0, t.z = 0;
-    }
-    ILINE QuatT_tpl(type_identity)
-    {
-        q.w = 1, q.v.x = 0, q.v.y = 0, q.v.z = 0, t.x = 0, t.y = 0, t.z = 0;
-    }
-
-    ILINE QuatT_tpl(const Vec3_tpl<F>& _t, const Quat_tpl<F>& _q) { q = _q; t = _t; }
-
-    //CONSTRUCTOR: implement the copy/casting/assignment constructor:
-    template <typename F1>
-    ILINE QuatT_tpl(const QuatT_tpl<F1>& qt)
-        : q(qt.q)
-        , t(qt.t) {}
-
-    //convert unit DualQuat back to QuatT
-    ILINE QuatT_tpl(const DualQuat_tpl<F>& qd)
-    {
-        //copy quaternion part
-        q = qd.nq;
-        //convert translation vector:
-        t = (qd.nq.w * qd.dq.v - qd.dq.w * qd.nq.v + qd.nq.v % qd.dq.v) * 2; //perfect for HLSL
-    }
-
-    explicit ILINE QuatT_tpl(const QuatTS_tpl<F>& qts)
-        : q(qts.q)
-        , t(qts.t) {}
-
-    explicit ILINE QuatT_tpl(const Matrix34_tpl<F>& m)
-    {
-        q = Quat_tpl<F>(Matrix33(m));
-        t = m.GetTranslation();
-    }
-
-    ILINE QuatT_tpl(const Quat_tpl<F>& quat, const Vec3_tpl<F>& trans)
-    {
-        q = quat;
-        t = trans;
-    }
-
-    ILINE void SetIdentity()
-    {
-        q.w = 1;
-        q.v.x = 0;
-        q.v.y = 0;
-        q.v.z = 0;
-        t.x = 0;
-        t.y = 0;
-        t.z = 0;
-    }
-
-    ILINE bool IsIdentity() const
-    {
-        return (q.IsIdentity() && t.IsZero());
-    }
-
-    /*!
-    * Convert three Euler angle to mat33 (rotation order:XYZ)
-    * The Euler angles are assumed to be in radians.
-    * The translation-vector is set to zero by default.
-    *
-    *  Example 1:
-    *       QuatT qp;
-    *       qp.SetRotationXYZ( Ang3(0.5f,0.2f,0.9f), translation );
-    *
-    *  Example 2:
-    *       QuatT qp=QuatT::CreateRotationXYZ( Ang3(0.5f,0.2f,0.9f), translation );
-    */
-    ILINE void SetRotationXYZ(const Ang3_tpl<F>& rad, const Vec3_tpl<F>& trans = Vec3(ZERO))
-    {
-        assert(rad.IsValid());
-        assert(trans.IsValid());
-        q.SetRotationXYZ(rad);
-        t = trans;
-    }
-    ILINE static QuatT_tpl<F> CreateRotationXYZ(const Ang3_tpl<F>& rad, const Vec3_tpl<F>& trans = Vec3(ZERO))
-    {
-        assert(rad.IsValid());
-        assert(trans.IsValid());
-        QuatT_tpl<F> qp;
-        qp.SetRotationXYZ(rad, trans);
-        return qp;
-    }
-
-
-
-    ILINE void SetRotationAA(F cosha, F sinha, const Vec3_tpl<F> axis, const Vec3_tpl<F>& trans = Vec3(ZERO))
-    {
-        q.SetRotationAA(cosha, sinha, axis);
-        t = trans;
-    }
-    ILINE static QuatT_tpl<F> CreateRotationAA(F cosha, F sinha, const Vec3_tpl<F> axis, const Vec3_tpl<F>& trans = Vec3(ZERO))
-    {
-        QuatT_tpl<F> qt;
-        qt.SetRotationAA(cosha, sinha, axis, trans);
-        return qt;
-    }
-
-
-    ILINE void Invert()
-    { // in-place transposition
-        assert(q.IsValid());
-        t = -t * q;
-        q = !q;
-    }
-    ILINE QuatT_tpl<F> GetInverted() const
-    {
-        assert(q.IsValid());
-        QuatT_tpl<F> qpos;
-        qpos.q = !q;
-        qpos.t = -t * q;
-        return qpos;
-    }
-
-    ILINE void SetTranslation(const Vec3_tpl<F>& trans)   {   t = trans;    }
-
-    ILINE Vec3_tpl<F> GetColumn0() const {return q.GetColumn0(); }
-    ILINE Vec3_tpl<F> GetColumn1() const {return q.GetColumn1(); }
-    ILINE Vec3_tpl<F> GetColumn2() const {return q.GetColumn2(); }
-    ILINE Vec3_tpl<F> GetColumn3() const {return t; }
-    ILINE Vec3_tpl<F> GetRow0() const { return q.GetRow0(); }
-    ILINE Vec3_tpl<F> GetRow1() const { return q.GetRow1(); }
-    ILINE Vec3_tpl<F> GetRow2() const { return q.GetRow2(); }
-
-    ILINE static bool IsEquivalent(const QuatT_tpl<F>& qt1, const QuatT_tpl<F>& qt2, F qe = RAD_EPSILON, F ve = VEC_EPSILON)
-    {
-        real rad = acos(min(1.0f, fabs_tpl(qt1.q | qt2.q)));
-        bool qdif = rad <= qe;
-        bool vdif   = fabs_tpl(qt1.t.x - qt2.t.x) <= ve && fabs_tpl(qt1.t.y - qt2.t.y) <= ve && fabs_tpl(qt1.t.z - qt2.t.z) <= ve;
-        return (qdif && vdif);
-    }
-
-    ILINE bool IsValid() const
-    {
-        if (!t.IsValid())
-        {
-            return false;
-        }
-        if (!q.IsValid())
-        {
-            return false;
-        }
-        return true;
-    }
-
-    /*!
-    * linear-interpolation between quaternions (lerp)
-    *
-    * Example:
-    *  CQuaternion result,p,q;
-    *  result=qlerp( p, q, 0.5f );
-    */
-    ILINE void SetNLerp(const QuatT_tpl<F>& p, const QuatT_tpl<F>& tq, F ti)
-    {
-        assert(p.q.IsValid());
-        assert(tq.q.IsValid());
-        Quat_tpl<F> d = tq.q;
-        if ((p.q | d) < 0)
-        {
-            d = -d;
-        }
-        Vec3_tpl<F> vDiff = d.v - p.q.v;
-        q.v = p.q.v + (vDiff * ti);
-        q.w = p.q.w + ((d.w - p.q.w) * ti);
-        q.Normalize();
-        vDiff = tq.t - p.t;
-        t = p.t + (vDiff * ti);
-    }
-    ILINE static QuatT_tpl<F> CreateNLerp(const QuatT_tpl<F>& p, const QuatT_tpl<F>& q, F t)
-    {
-        QuatT_tpl<F> d;
-        d.SetNLerp(p, q, t);
-        return d;
-    }
-
-    //NOTE: all vectors are stored in columns
-    ILINE void SetFromVectors(const Vec3& vx, const Vec3& vy, const Vec3& vz, const Vec3& pos)
-    {
-        Matrix34 m34;
-        m34.m00 = vx.x;
-        m34.m01 = vy.x;
-        m34.m02 = vz.x;
-        m34.m03 = pos.x;
-        m34.m10 = vx.y;
-        m34.m11 = vy.y;
-        m34.m12 = vz.y;
-        m34.m13 = pos.y;
-        m34.m20 = vx.z;
-        m34.m21 = vy.z;
-        m34.m22 = vz.z;
-        m34.m23 = pos.z;
-        *this = QuatT_tpl<F>(m34);
-    }
-    ILINE static QuatT_tpl<F> CreateFromVectors(const Vec3_tpl<F>& vx, const Vec3_tpl<F>& vy, const Vec3_tpl<F>& vz, const Vec3_tpl<F>& pos)
-    {
-        QuatT_tpl<F> qt;
-        qt.SetFromVectors(vx, vy, vz, pos);
-        return qt;
-    }
-
-    QuatT_tpl<F> GetScaled(F scale)
-    {
-        return QuatT_tpl<F>(t * scale, q.GetScaled(scale));
-    }
-};
-
-typedef QuatT_tpl<f32>  QuatT; //always 32 bit
-typedef QuatT_tpl<f64>  QuatTd;//always 64 bit
-typedef QuatT_tpl<real> QuatTr;//variable float precision. depending on the target system it can be between 32, 64 or bit
-
-/*!
-*
-*  Implements the multiplication operator: QuatT=Quatpos*Quat
-*
-*  AxB = operation B followed by operation A.
-*  A multiplication takes 16 muls and 12 adds (=28 float operations).
-*
-*  Example:
-*   Quat    quat        =   Quat::CreateRotationX(1.94192f);;
-*   QuatT quatpos   =   QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
-*     QuatT qp          =   quatpos*quat;
-*/
-template<class F1, class F2>
-ILINE QuatT_tpl<F1> operator * (const QuatT_tpl<F1>& p, const Quat_tpl<F2>& q)
-{
-    assert(p.IsValid());
-    assert(q.IsValid());
-    return QuatT_tpl<F1>(p.q * q, p.t);
-}
-
-/*!
-*  Implements the multiplication operator: QuatT=QuatposA*QuatposB
-*
-*  AxB = operation B followed by operation A.
-*  A multiplication takes 31 muls and 30 adds  (=61 float operations).
-*
-*  Example:
-*   QuatT quatposA  =   QuatT::CreateRotationX(1.94192f,Vec3(77,55,44));
-*   QuatT quatposB  =   QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
-*     QuatT qp              =   quatposA*quatposB;
-*/
-template<class F1, class F2>
-ILINE QuatT_tpl<F1> operator * (const QuatT_tpl<F1>& q, const QuatT_tpl<F2>& p)
-{
-    assert(q.IsValid());
-    assert(p.IsValid());
-    return QuatT_tpl<F1>(q.q * p.q, q.q * p.t + q.t);
-}
-
-
-
-/*!
-* post-multiply of a QuatT and a Vec3 (3D rotations with quaternions)
-*
-* Example:
-*  Quat q(1,0,0,0);
-*  Vec3 v(33,44,55);
-*    Vec3 result = q*v;
-*/
-template<class F, class F2>
-Vec3_tpl<F> operator * (const QuatT_tpl<F>& q, const Vec3_tpl<F2>& v)
-{
-    assert(v.IsValid());
-    assert(q.IsValid());
-    //muls=15 / adds=15+3
-    Vec3_tpl<F> out, r2;
-    r2.x = (q.q.v.y * v.z - q.q.v.z * v.y) + q.q.w * v.x;
-    r2.y = (q.q.v.z * v.x - q.q.v.x * v.z) + q.q.w * v.y;
-    r2.z = (q.q.v.x * v.y - q.q.v.y * v.x) + q.q.w * v.z;
-    out.x = (r2.z * q.q.v.y - r2.y * q.q.v.z);
-    out.x += out.x + v.x + q.t.x;
-    out.y = (r2.x * q.q.v.z - r2.z * q.q.v.x);
-    out.y += out.y + v.y + q.t.y;
-    out.z = (r2.y * q.q.v.x - r2.x * q.q.v.y);
-    out.z += out.z + v.z + q.t.z;
-    return out;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//----------------------------------------------------------------------
-// Quaternion with translation vector and scale
-// Similar to QuatT, but s is not ignored.
-// Most functions then differ, so we don't inherit.
-//----------------------------------------------------------------------
-template <typename F>
-struct QuatTS_tpl
-{
-    Quat_tpl<F> q;
-    Vec3_tpl<F> t;
-    F                       s;
-
-    //constructors
-#if defined(_DEBUG)
-    ILINE QuatTS_tpl()
-    {
-        if constexpr (sizeof(F) == 4)
-        {
-            uint32* p = alias_cast<uint32*>(&q.v.x);
-            p[0] = F32NAN;
-            p[1] = F32NAN;
-            p[2] = F32NAN;
-            p[3] = F32NAN;
-            p[4] = F32NAN;
-            p[5] = F32NAN;
-            p[6] = F32NAN;
-            p[7] = F32NAN;
-        }
-        if constexpr (sizeof(F) == 8)
-        {
-            uint64* p = alias_cast<uint64*>(&q.v.x);
-            p[0] = F64NAN;
-            p[1] = F64NAN;
-            p[2] = F64NAN;
-            p[3] = F64NAN;
-            p[4] = F64NAN;
-            p[5] = F64NAN;
-            p[6] = F64NAN;
-            p[7] = F64NAN;
-        }
-    }
-#else
-    ILINE QuatTS_tpl(){}
-#endif
-
-    ILINE QuatTS_tpl(const Quat_tpl<F>& quat, const Vec3_tpl<F>& trans, F scale = 1)    { q = quat; t = trans; s = scale; }
-    ILINE QuatTS_tpl(type_identity) { SetIdentity(); }
-
-    //CONSTRUCTOR: implement the copy/casting/assignment constructor:
-    template <typename F1>
-    ILINE QuatTS_tpl(const QuatTS_tpl<F1>& qts)
-        :  q(qts.q)
-        , t(qts.t)
-        , s(qts.s)    {}
-
-    ILINE QuatTS_tpl& operator = (const QuatT_tpl<F>& qt)
-    {
-        q = qt.q;
-        t = qt.t;
-        s = 1.0f;
-        return *this;
-    }
-    ILINE QuatTS_tpl(const QuatT_tpl<F>& qp)  { q = qp.q; t = qp.t; s = 1.0f; }
-
-
-    ILINE void SetIdentity()
-    {
-        q.SetIdentity();
-        t = Vec3(ZERO);
-        s = 1;
-    }
-
-    explicit ILINE QuatTS_tpl(const Matrix34_tpl<F>& m)
-    {
-        t = m.GetTranslation();
-
-        // The determinant of a matrix is the volume spanned by its base vectors.
-        // We need an approximate length scale, so we calculate the cube root of the determinant.
-        s = pow(m.Determinant(), F(1.0 / 3.0));
-
-        // Orthonormalize using X and Z as anchors.
-        const Vec3_tpl<F>& r0 = m.GetRow(0);
-        const Vec3_tpl<F>& r2 = m.GetRow(2);
-
-        const Vec3_tpl<F> v0 = r0.GetNormalized();
-        const Vec3_tpl<F> v1 = (r2 % r0).GetNormalized();
-        const Vec3_tpl<F> v2 = (v0 % v1);
-
-        Matrix33_tpl<F> m3;
-        m3.SetRow(0, v0);
-        m3.SetRow(1, v1);
-        m3.SetRow(2, v2);
-
-        q = Quat_tpl<F>(m3);
-    }
-
-    void Invert()
-    {
-        s = 1 / s;
-        q = !q;
-        t = q * t * -s;
-    }
-    QuatTS_tpl<F> GetInverted() const
-    {
-        QuatTS_tpl<F> inv;
-        inv.s = 1 / s;
-        inv.q = !q;
-        inv.t = inv.q * t * -inv.s;
-        return inv;
-    }
-
-
-    /*!
-    * linear-interpolation between quaternions (nlerp)
-    *
-    * Example:
-    *  CQuaternion result,p,q;
-    *  result=qlerp( p, q, 0.5f );
-    */
-    ILINE void SetNLerp(const QuatTS_tpl<F>& p, const QuatTS_tpl<F>& tq, F ti)
-    {
-        assert(p.q.IsValid());
-        assert(tq.q.IsValid());
-        Quat_tpl<F> d = tq.q;
-        if ((p.q | d) < 0)
-        {
-            d = -d;
-        }
-        Vec3_tpl<F> vDiff = d.v - p.q.v;
-        q.v = p.q.v + (vDiff * ti);
-        q.w = p.q.w + ((d.w - p.q.w) * ti);
-        q.Normalize();
-
-        vDiff = tq.t - p.t;
-        t = p.t + (vDiff * ti);
-
-        s     = p.s + ((tq.s - p.s) * ti);
-    }
-
-    ILINE static QuatTS_tpl<F> CreateNLerp(const QuatTS_tpl<F>& p, const QuatTS_tpl<F>& q, F t)
-    {
-        QuatTS_tpl<F> d;
-        d.SetNLerp(p, q, t);
-        return d;
-    }
-
-
-
-    ILINE static bool IsEquivalent(const QuatTS_tpl<F>& qts1, const QuatTS_tpl<F>& qts2, F qe = RAD_EPSILON, F ve = VEC_EPSILON)
-    {
-        f64 rad  =  acos(min(1.0f, fabs_tpl(qts1.q | qts2.q)));
-        bool qdif = rad <= qe;
-        bool vdif   = fabs_tpl(qts1.t.x - qts2.t.x) <= ve && fabs_tpl(qts1.t.y - qts2.t.y) <= ve && fabs_tpl(qts1.t.z - qts2.t.z) <= ve;
-        bool sdif   = fabs_tpl(qts1.s - qts2.s) <= ve;
-        return (qdif && vdif && sdif);
-    }
-
-
-    bool IsValid(F e = VEC_EPSILON) const
-    {
-        if (!q.v.IsValid())
-        {
-            return false;
-        }
-        if (!NumberValid(q.w))
-        {
-            return false;
-        }
-        if (!q.IsUnit(e))
-        {
-            return false;
-        }
-        if (!t.IsValid())
-        {
-            return false;
-        }
-        if (!NumberValid(s))
-        {
-            return false;
-        }
-        return true;
-    }
-
-    ILINE Vec3_tpl<F> GetColumn0() const {return q.GetColumn0(); }
-    ILINE Vec3_tpl<F> GetColumn1() const {return q.GetColumn1(); }
-    ILINE Vec3_tpl<F> GetColumn2() const {return q.GetColumn2(); }
-    ILINE Vec3_tpl<F> GetColumn3() const {return t; }
-    ILINE Vec3_tpl<F> GetRow0() const { return q.GetRow0(); }
-    ILINE Vec3_tpl<F> GetRow1() const { return q.GetRow1(); }
-    ILINE Vec3_tpl<F> GetRow2() const { return q.GetRow2(); }
-};
-
-typedef QuatTS_tpl<f32>  QuatTS; //always 64 bit
-typedef QuatTS_tpl<f64>  QuatTSd;//always 64 bit
-typedef QuatTS_tpl<real> QuatTSr;//variable float precision. depending on the target system it can be between 32, 64 or 80 bit
-
-template<class F1, class F2>
-ILINE QuatTS_tpl<F1> operator * (const QuatTS_tpl<F1>& a, const Quat_tpl<F2>& b)
-{
-    return QuatTS_tpl<F1>(a.q * b, a.t, a.s);
-}
-
-
-template<class F1, class F2>
-ILINE QuatTS_tpl<F1> operator * (const QuatTS_tpl<F1>& a, const QuatT_tpl<F2>& b)
-{
-    return QuatTS_tpl<F1>(a.q * b.q, a.q * (b.t * a.s) + a.t, a.s);
-}
-template<class F1, class F2>
-ILINE QuatTS_tpl<F1> operator * (const QuatT_tpl<F1>& a, const QuatTS_tpl<F2>& b)
-{
-    return QuatTS_tpl<F1>(a.q * b.q, a.q * b.t + a.t, b.s);
-}
-template<class F1, class F2>
-ILINE QuatTS_tpl<F1> operator * (const Quat_tpl<F1>& a, const QuatTS_tpl<F2>& b)
-{
-    return QuatTS_tpl<F1>(a * b.q, a * b.t, b.s);
-}
-
-/*!
-*  Implements the multiplication operator: QuatTS=QuatTS*QuatTS
-*/
-template<class F1, class F2>
-ILINE QuatTS_tpl<F1> operator * (const QuatTS_tpl<F1>& a, const QuatTS_tpl<F2>& b)
-{
-    assert(a.IsValid());
-    assert(b.IsValid());
-    return QuatTS_tpl<F1>(a.q * b.q, a.q * (b.t * a.s) + a.t, a.s * b.s);
-}
-
-/*!
-* post-multiply of a QuatT and a Vec3 (3D rotations with quaternions)
-*/
-template<class F, class F2>
-ILINE Vec3_tpl<F> operator * (const QuatTS_tpl<F>& q, const Vec3_tpl<F2>& v)
-{
-    assert(q.IsValid());
-    assert(v.IsValid());
-    return q.q * v * q.s + q.t;
-}
-
-
-//----------------------------------------------------------------------
-// Quaternion with translation vector and non-uniform scale
-//----------------------------------------------------------------------
-template <typename F>
-struct QuatTNS_tpl
-{
-    Quat_tpl<F> q;
-    Vec3_tpl<F> t;
-    Vec3_tpl<F> s;
-
-    //constructors
-#if defined(_DEBUG)
-    ILINE QuatTNS_tpl()
-    {
-        if constexpr (sizeof(F) == 4)
-        {
-            uint32* p = alias_cast<uint32*>(&q.v.x);
-            p[0] = F32NAN;
-            p[1] = F32NAN;
-            p[2] = F32NAN;
-            p[3] = F32NAN;
-            p[4] = F32NAN;
-            p[5] = F32NAN;
-            p[6] = F32NAN;
-            p[7] = F32NAN;
-            p[8] = F32NAN;
-            p[9] = F32NAN;
-        }
-        if constexpr (sizeof(F) == 8)
-        {
-            uint64* p = alias_cast<uint64*>(&q.v.x);
-            p[0] = F64NAN;
-            p[1] = F64NAN;
-            p[2] = F64NAN;
-            p[3] = F64NAN;
-            p[4] = F64NAN;
-            p[5] = F64NAN;
-            p[6] = F64NAN;
-            p[7] = F64NAN;
-            p[8] = F64NAN;
-            p[9] = F64NAN;
-        }
-    }
-#else
-    ILINE QuatTNS_tpl() {};
-#endif
-
-    ILINE QuatTNS_tpl(const Quat_tpl<F>& quat, const Vec3_tpl<F>& trans, const Vec3_tpl<F>& scale = Vec3_tpl<F>(1)) { q = quat; t = trans; s = scale; }
-    ILINE QuatTNS_tpl(type_identity) { SetIdentity(); }
-
-    //CONSTRUCTOR: implement the copy/casting/assignment constructor:
-    template <typename F1>
-    ILINE QuatTNS_tpl(const QuatTS_tpl<F1>& qts)
-        :     q(qts.q)
-        , t(qts.t)
-        , s(qts.s)
-    {
-    }
-
-    ILINE QuatTNS_tpl& operator = (const QuatT_tpl<F>& qt)
-    {
-        q = qt.q;
-        t = qt.t;
-        s = Vec3_tpl<F>(1);
-        return *this;
-    }
-    ILINE QuatTNS_tpl(const QuatT_tpl<F>& qp) { q = qp.q; t = qp.t; s = Vec3_tpl<F>(1); }
-
-
-    ILINE void SetIdentity()
-    {
-        q.SetIdentity();
-        t = Vec3_tpl<F>(ZERO);
-        s = Vec3_tpl<F>(1);
-    }
-
-    explicit ILINE QuatTNS_tpl(const Matrix34_tpl<F>& m)
-    {
-        t = m.GetTranslation();
-
-        // Lengths of base vectors equates to scaling in matrix
-        s.x = m.GetColumn0().GetLength();
-        s.y = m.GetColumn1().GetLength();
-        s.z = m.GetColumn2().GetLength();
-
-        // Orthonormalize using X and Z as anchors.
-        const Vec3_tpl<F>& r0 = m.GetRow(0);
-        const Vec3_tpl<F>& r2 = m.GetRow(2);
-
-        const Vec3_tpl<F> v0 = r0.GetNormalized();
-        const Vec3_tpl<F> v1 = (r2 % r0).GetNormalized();
-        const Vec3_tpl<F> v2 = (v0 % v1);
-
-        Matrix33_tpl<F> m3;
-        m3.SetRow(0, v0);
-        m3.SetRow(1, v1);
-        m3.SetRow(2, v2);
-
-        q = Quat_tpl<F>(m3);
-    }
-
-    void Invert()
-    {
-        s = Vec3_tpl<F>(1) / s;
-        q = !q;
-        t = q * t * -s;
-    }
-    QuatTNS_tpl<F> GetInverted() const
-    {
-        QuatTNS_tpl<F> inv;
-        inv.s = Vec3_tpl<F>(1) / s;
-        inv.q = !q;
-        inv.t = inv.q * t * -inv.s;
-        return inv;
-    }
-
-
-    /*!
-    * linear-interpolation between quaternions (nlerp)
-    *
-    * Example:
-    *  CQuaternion result,p,q;
-    *  result=qlerp( p, q, 0.5f );
-    */
-    ILINE void SetNLerp(const QuatTNS_tpl<F>& p, const QuatTNS_tpl<F>& tq, F ti)
-    {
-        assert(p.q.IsValid());
-        assert(tq.q.IsValid());
-        Quat_tpl<F> d = tq.q;
-        if ((p.q | d) < 0)
-        {
-            d = -d;
-        }
-        Vec3_tpl<F> vDiff = d.v - p.q.v;
-        q.v = p.q.v + (vDiff * ti);
-        q.w = p.q.w + ((d.w - p.q.w) * ti);
-        q.Normalize();
-
-        vDiff = tq.t - p.t;
-        t = p.t + (vDiff * ti);
-
-        s     = p.s + ((tq.s - p.s) * ti);
-    }
-
-    ILINE static QuatTNS_tpl<F> CreateNLerp(const QuatTNS_tpl<F>& p, const QuatTNS_tpl<F>& q, F t)
-    {
-        QuatTNS_tpl<F> d;
-        d.SetNLerp(p, q, t);
-        return d;
-    }
-
-
-
-    ILINE static bool IsEquivalent(const QuatTNS_tpl<F>& qts1, const QuatTNS_tpl<F>& qts2, F qe = RAD_EPSILON, F ve = VEC_EPSILON)
-    {
-        real rad  = acos(min(1.0f, fabs_tpl(qts1.q | qts2.q)));
-        bool qdif = rad <= qe;
-        bool vdif   = fabs_tpl(qts1.t.x - qts2.t.x) <= ve && fabs_tpl(qts1.t.y - qts2.t.y) <= ve && fabs_tpl(qts1.t.z - qts2.t.z) <= ve;
-        bool sdif   = fabs_tpl(qts1.s.x - qts2.s.x) <= ve && fabs_tpl(qts1.s.y - qts2.s.y) <= ve && fabs_tpl(qts1.s.z - qts2.s.z) <= ve;
-        return (qdif && vdif && sdif);
-    }
-
-
-    bool IsValid(F e = VEC_EPSILON) const
-    {
-        if (!q.v.IsValid())
-        {
-            return false;
-        }
-        if (!NumberValid(q.w))
-        {
-            return false;
-        }
-        if (!q.IsUnit(e))
-        {
-            return false;
-        }
-        if (!t.IsValid())
-        {
-            return false;
-        }
-        if (!NumberValid(s.x))
-        {
-            return false;
-        }
-        if (!NumberValid(s.y))
-        {
-            return false;
-        }
-        if (!NumberValid(s.z))
-        {
-            return false;
-        }
-        return true;
-    }
-
-    ILINE Vec3_tpl<F> GetColumn0() const {return q.GetColumn0(); }
-    ILINE Vec3_tpl<F> GetColumn1() const {return q.GetColumn1(); }
-    ILINE Vec3_tpl<F> GetColumn2() const {return q.GetColumn2(); }
-    ILINE Vec3_tpl<F> GetColumn3() const {return t; }
-    ILINE Vec3_tpl<F> GetRow0() const { return q.GetRow0(); }
-    ILINE Vec3_tpl<F> GetRow1() const { return q.GetRow1(); }
-    ILINE Vec3_tpl<F> GetRow2() const { return q.GetRow2(); }
-};
-
-typedef QuatTNS_tpl<f32> QuatTNS;
-typedef QuatTNS_tpl<f64> QuatTNSr;
-typedef QuatTNS_tpl<f64> QuatTNS_f64;
-
-template<class F1, class F2>
-ILINE QuatTNS_tpl<F1> operator * (const QuatTNS_tpl<F1>& a, const Quat_tpl<F2>& b)
-{
-    return QuatTNS_tpl<F1>(a.q * b, a.t, a.s);
-}
-
-template<class F1, class F2>
-ILINE QuatTNS_tpl<F1> operator * (const Quat_tpl<F1>& a, const QuatTNS_tpl<F2>& b)
-{
-    return QuatTNS_tpl<F1>(a * b.q, a * b.t, b.s);
-}
-
-template<class F1, class F2>
-ILINE QuatTNS_tpl<F1> operator * (const QuatTNS_tpl<F1>& a, const QuatT_tpl<F2>& b)
-{
-    return QuatTNS_tpl<F1>(a.q * b.q, a.q * Vec3_tpl<F1>(b.x * a.s.x, b.y * a.s.y, b.z * a.s.z) + a.t, a.s);
-}
-
-template<class F1, class F2>
-ILINE QuatTNS_tpl<F1> operator * (const QuatT_tpl<F1>& a, const QuatTNS_tpl<F2>& b)
-{
-    return QuatTNS_tpl<F1>(a.q * b.q, a.q * b.t + a.t, b.s);
-}
-
-/*!
-*  Implements the multiplication operator: QuatTNS=QuatTNS*QuatTNS
-*/
-template<class F1, class F2>
-ILINE QuatTNS_tpl<F1> operator * (const QuatTNS_tpl<F1>& a, const QuatTNS_tpl<F2>& b)
-{
-    assert(a.IsValid());
-    assert(b.IsValid());
-    return QuatTNS_tpl<F1>(
-        a.q * b.q,
-        a.q * Vec3_tpl<F1>(b.t.x * a.s.x, b.t.y * a.s.y, b.t.z * a.s.z) + a.t,
-        Vec3_tpl<F1>(a.s.x * b.s.x, a.s.y * b.s.y, a.s.z * b.s.z)
-        );
-}
-
-/*!
-* post-multiply of a QuatTNS and a Vec3 (3D rotations with quaternions)
-*/
-template<class F1, class F2>
-ILINE Vec3_tpl<F1> operator * (const QuatTNS_tpl<F1>& q, const Vec3_tpl<F2>& v)
-{
-    assert(q.IsValid());
-    assert(v.IsValid());
-    return q.q * Vec3_tpl<F1>(v.x * q.s.x, v.y * q.s.y, v.z * q.s.z) + q.t;
-}
-
-//----------------------------------------------------------------------
-// Dual Quaternion
-//----------------------------------------------------------------------
-template <typename F>
-struct DualQuat_tpl
-{
-    Quat_tpl<F> nq;
-    Quat_tpl<F> dq;
-
-    ILINE DualQuat_tpl()  {}
-
-    ILINE DualQuat_tpl(const Quat_tpl<F>& q, const Vec3_tpl<F>& t)
-    {
-        //copy the quaternion part
-        nq = q;
-        //convert the translation into a dual quaternion part
-        dq.w        = -0.5f * (t.x * q.v.x  + t.y * q.v.y + t.z * q.v.z);
-        dq.v.x  = 0.5f * (t.x * q.w        + t.y * q.v.z - t.z * q.v.y);
-        dq.v.y  = 0.5f * (-t.x * q.v.z  + t.y * q.w       + t.z * q.v.x);
-        dq.v.z  = 0.5f * (t.x * q.v.y  - t.y * q.v.x + t.z * q.w);
-    }
-
-    ILINE DualQuat_tpl(const QuatT_tpl<F>& qt)
-    {
-        //copy the quaternion part
-        nq = qt.q;
-        //convert the translation into a dual quaternion part
-        dq.w        = -0.5f * (qt.t.x * qt.q.v.x    + qt.t.y * qt.q.v.y   + qt.t.z * qt.q.v.z);
-        dq.v.x  = 0.5f * (qt.t.x * qt.q.w      - qt.t.z * qt.q.v.y + qt.t.y * qt.q.v.z);
-        dq.v.y  = 0.5f * (qt.t.y * qt.q.w      - qt.t.x * qt.q.v.z   + qt.t.z * qt.q.v.x);
-        dq.v.z  = 0.5f * (qt.t.x * qt.q.v.y    - qt.t.y * qt.q.v.x   + qt.t.z * qt.q.w);
-    }
-
-    explicit ILINE DualQuat_tpl( const Matrix34_tpl<F>& m34 )
-    {
-        // non-dual part (just copy q0):
-        nq = Quat_tpl<F>(m34);
-        f32 tx = m34.m03;
-        f32 ty = m34.m13;
-        f32 tz = m34.m23;
-
-        // dual part:
-        dq.w        = -0.5f * (tx * nq.v.x  + ty * nq.v.y + tz * nq.v.z);
-        dq.v.x  = 0.5f * (tx * nq.w        + ty * nq.v.z - tz * nq.v.y);
-        dq.v.y  = 0.5f * (-tx * nq.v.z  + ty * nq.w       + tz * nq.v.x);
-        dq.v.z  = 0.5f * (tx * nq.v.y  - ty * nq.v.x + tz * nq.w);
-    }
-
-
-    ILINE DualQuat_tpl(type_identity)
-    {
-        SetIdentity();
-    }
-
-    ILINE DualQuat_tpl(type_zero)
-    {
-        SetZero();
-    }
-
-    template <typename F1>
-    ILINE DualQuat_tpl(const DualQuat_tpl<F1>& QDual)
-        : nq(QDual.nq)
-        , dq(QDual.dq) {}
-
-    ILINE void SetIdentity()
-    {
-        nq.SetIdentity();
-        dq.w = 0.0f;
-        dq.v.x = 0.0f;
-        dq.v.y = 0.0f;
-        dq.v.z = 0.0f;
-    }
-
-    ILINE void SetZero()
-    {
-        nq.w = 0.0f;
-        nq.v.x = 0.0f;
-        nq.v.y = 0.0f;
-        nq.v.z = 0.0f;
-        dq.w = 0.0f;
-        dq.v.x = 0.0f;
-        dq.v.y = 0.0f;
-        dq.v.z = 0.0f;
-    }
-
-    ILINE void Normalize()
-    {
-        // Normalize both components so that nq is unit
-        F norm = isqrt_safe_tpl(nq.v.len2() + sqr(nq.w));
-        nq *= norm;
-        dq *= norm;
-    }
-};
-
-#ifndef MAX_API_NUM
-typedef DualQuat_tpl<f32>  DualQuat; //always 32 bit
-typedef DualQuat_tpl<f64>  DualQuatd;//always 64 bit
-typedef DualQuat_tpl<real> DualQuatr;//variable float precision. depending on the target system it can be between 32, 64 or 80 bit
-#else
-typedef DualQuat_tpl<f32> CryDualQuat;
-#endif
-
-template<class F1, class F2>
-ILINE DualQuat_tpl<F1> operator*(const DualQuat_tpl<F1>& l, const F2 r)
-{
-    DualQuat_tpl<F1> dual;
-    dual.nq.w  = l.nq.w  * r;
-    dual.nq.v.x = l.nq.v.x * r;
-    dual.nq.v.y = l.nq.v.y * r;
-    dual.nq.v.z = l.nq.v.z * r;
-
-    dual.dq.w  = l.dq.w  * r;
-    dual.dq.v.x = l.dq.v.x * r;
-    dual.dq.v.y = l.dq.v.y * r;
-    dual.dq.v.z = l.dq.v.z * r;
-    return dual;
-}
-
-template<class F1, class F2>
-ILINE DualQuat_tpl<F1> operator+(const DualQuat_tpl<F1>& l, const DualQuat_tpl<F2>& r)
-{
-    DualQuat_tpl<F1> dual;
-    dual.nq.w  = l.nq.w  + r.nq.w;
-    dual.nq.v.x = l.nq.v.x + r.nq.v.x;
-    dual.nq.v.y = l.nq.v.y + r.nq.v.y;
-    dual.nq.v.z = l.nq.v.z + r.nq.v.z;
-
-    dual.dq.w  = l.dq.w  + r.dq.w;
-    dual.dq.v.x = l.dq.v.x + r.dq.v.x;
-    dual.dq.v.y = l.dq.v.y + r.dq.v.y;
-    dual.dq.v.z = l.dq.v.z + r.dq.v.z;
-    return dual;
-}
-
-template<class F1, class F2>
-ILINE void operator += (DualQuat_tpl<F1>& l, const DualQuat_tpl<F2>& r)
-{
-    l.nq.w  += r.nq.w;
-    l.nq.v.x += r.nq.v.x;
-    l.nq.v.y += r.nq.v.y;
-    l.nq.v.z += r.nq.v.z;
-
-    l.dq.w  += r.dq.w;
-    l.dq.v.x += r.dq.v.x;
-    l.dq.v.y += r.dq.v.y;
-    l.dq.v.z += r.dq.v.z;
-}
-
-template<class F1, class F2>
-ILINE Vec3_tpl<F1> operator*(const DualQuat_tpl<F1>& dq, const Vec3_tpl<F2>& v)
-{
-    F2 t;
-    const F2 ax = dq.nq.v.y * v.z - dq.nq.v.z * v.y + dq.nq.w * v.x;
-    const F2 ay = dq.nq.v.z * v.x - dq.nq.v.x * v.z + dq.nq.w * v.y;
-    const F2 az = dq.nq.v.x * v.y - dq.nq.v.y * v.x + dq.nq.w * v.z;
-    F2 x = dq.dq.v.x * dq.nq.w - dq.nq.v.x * dq.dq.w + dq.nq.v.y * dq.dq.v.z - dq.nq.v.z * dq.dq.v.y;
-    x += x;
-    t = (az * dq.nq.v.y - ay * dq.nq.v.z);
-    x += t + t + v.x;
-    F2 y = dq.dq.v.y * dq.nq.w - dq.nq.v.y * dq.dq.w + dq.nq.v.z * dq.dq.v.x - dq.nq.v.x * dq.dq.v.z;
-    y += y;
-    t = (ax * dq.nq.v.z - az * dq.nq.v.x);
-    y += t + t + v.y;
-    F2 z = dq.dq.v.z * dq.nq.w - dq.nq.v.z * dq.dq.w + dq.nq.v.x * dq.dq.v.y - dq.nq.v.y * dq.dq.v.x;
-    z += z;
-    t = (ay * dq.nq.v.x - ax * dq.nq.v.y);
-    z += t + t + v.z;
-    return Vec3_tpl<F2>(x, y, z);
-}
-
-template<class F1, class F2>
-ILINE DualQuat_tpl<F1> operator*(const DualQuat_tpl<F1>& a, const DualQuat_tpl<F2>& b)
-{
-    DualQuat_tpl<F1> dual;
-
-    dual.nq.v.x = a.nq.v.y * b.nq.v.z - a.nq.v.z * b.nq.v.y + a.nq.w * b.nq.v.x + a.nq.v.x * b.nq.w;
-    dual.nq.v.y = a.nq.v.z * b.nq.v.x - a.nq.v.x * b.nq.v.z + a.nq.w * b.nq.v.y + a.nq.v.y * b.nq.w;
-    dual.nq.v.z = a.nq.v.x * b.nq.v.y - a.nq.v.y * b.nq.v.x + a.nq.w * b.nq.v.z + a.nq.v.z * b.nq.w;
-    dual.nq.w = a.nq.w * b.nq.w  - (a.nq.v.x * b.nq.v.x + a.nq.v.y * b.nq.v.y + a.nq.v.z * b.nq.v.z);
-
-    //dual.dq   = a.nq*b.dq + a.dq*b.nq;
-    dual.dq.v.x = a.nq.v.y * b.dq.v.z - a.nq.v.z * b.dq.v.y + a.nq.w * b.dq.v.x + a.nq.v.x * b.dq.w;
-    dual.dq.v.y = a.nq.v.z * b.dq.v.x - a.nq.v.x * b.dq.v.z + a.nq.w * b.dq.v.y + a.nq.v.y * b.dq.w;
-    dual.dq.v.z = a.nq.v.x * b.dq.v.y - a.nq.v.y * b.dq.v.x + a.nq.w * b.dq.v.z + a.nq.v.z * b.dq.w;
-    dual.dq.w = a.nq.w * b.dq.w  - (a.nq.v.x * b.dq.v.x + a.nq.v.y * b.dq.v.y + a.nq.v.z * b.dq.v.z);
-
-    dual.dq.v.x += a.dq.v.y * b.nq.v.z - a.dq.v.z * b.nq.v.y + a.dq.w * b.nq.v.x + a.dq.v.x * b.nq.w;
-    dual.dq.v.y += a.dq.v.z * b.nq.v.x - a.dq.v.x * b.nq.v.z + a.dq.w * b.nq.v.y + a.dq.v.y * b.nq.w;
-    dual.dq.v.z += a.dq.v.x * b.nq.v.y - a.dq.v.y * b.nq.v.x + a.dq.w * b.nq.v.z + a.dq.v.z * b.nq.w;
-    dual.dq.w += a.dq.w * b.nq.w  - (a.dq.v.x * b.nq.v.x + a.dq.v.y * b.nq.v.y + a.dq.v.z * b.nq.v.z);
-
-    return dual;
-}
-
-
-#endif // CRYINCLUDE_CRYCOMMON_CRY_QUAT_H
-
-

Code/Legacy/CryCommon/Cry_Vector2.h

@@ -302,21 +302,13 @@ struct Vec2_tpl
 ///////////////////////////////////////////////////////////////////////////////
 
 typedef Vec2_tpl<f32>    Vec2;  // always 32 bit
-typedef Vec2_tpl<f64>    Vec2d; // always 64 bit
 typedef Vec2_tpl<int32>  Vec2i;
-typedef Vec2_tpl<uint32> Vec2ui;
-typedef Vec2_tpl<real>   Vec2r; // variable float precision. depending on the target system it can be 32, 64 or 80 bit
 
-typedef Vec2_tpl<float> vector2f;
 #if defined(LINUX64)
 typedef Vec2_tpl<int>    vector2l;
 #else
 typedef Vec2_tpl<long>   vector2l;
 #endif
-typedef Vec2_tpl<float> vector2df;
-typedef Vec2_tpl<real> vector2d;
-typedef Vec2_tpl<int> vector2di;
-typedef Vec2_tpl<unsigned int> vector2dui;
 
 template<class F>
 Vec2_tpl<F> operator*(F op1, const Vec2_tpl<F>& op2) {return Vec2_tpl<F>(op1 * op2.x, op1 * op2.y); }

Code/Legacy/CryCommon/Cry_Vector3.h

@@ -178,21 +178,6 @@ struct Vec3_tpl
         assert(IsValid());
     }
 
-    explicit ILINE Vec3_tpl<F>(const Vec4_tpl<F> &v) {
-        x = F(v.x);
-        y = F(v.y);
-        z = F(v.z);
-    }
-    template<class T>
-    explicit ILINE Vec3_tpl<F>(const Vec4_tpl<T> &v) {
-        x = F(v.x);
-        y = F(v.y);
-        z = F(v.z);
-    }
-
-
-
-
     /*!
     * overloaded arithmetic operator
     *
@@ -847,6 +832,8 @@ struct Vec3_tpl
     }
 };
 
+using Vec3i = Vec3_tpl<int32>;
+
 // dot product (2 versions)
 template<class F1, class F2>
 ILINE F1 operator * (const Vec3_tpl<F1>& v0, const Vec3_tpl<F2>& v1)
@@ -943,15 +930,6 @@ ILINE bool IsEquivalent(const Vec3_tpl<F>& v0, const Vec3_tpl<F>& v1, f32 epsilo
 ///////////////////////////////////////////////////////////////////////////////
 typedef Vec3_tpl<f32>    Vec3;  // always 32 bit
 
-typedef Vec3_tpl<f64>    Vec3d; // always 64 bit
-typedef Vec3_tpl<int32>  Vec3i;
-typedef Vec3_tpl<uint32> Vec3ui;
-typedef Vec3_tpl<real>   Vec3r; // variable float precision. depending on the target system it can be 32, 64 or 80 bit
-
-template<>
-inline Vec3_tpl<f64>::Vec3_tpl(type_min) { x = y = z = -1.7E308; }
-template<>
-inline Vec3_tpl<f64>::Vec3_tpl(type_max) { x = y = z = 1.7E308; }
 template<>
 inline Vec3_tpl<f32>::Vec3_tpl(type_min) { x = y = z = -3.3E38f; }
 template<>
@@ -1176,8 +1154,6 @@ struct Ang3_tpl
 };
 
 typedef Ang3_tpl<f32>       Ang3;
-typedef Ang3_tpl<real>  Ang3r;
-typedef Ang3_tpl<f64>       Ang3_f64;
 
 //---------------------------------------
 
@@ -1251,7 +1227,6 @@ struct AngleAxis_tpl
 };
 
 typedef AngleAxis_tpl<f32> AngleAxis;
-typedef AngleAxis_tpl<f64> AngleAxis_f64;
 
 template<typename F>
 ILINE const Vec3_tpl<F> AngleAxis_tpl<F>::operator * (const Vec3_tpl<F>& v) const
@@ -1260,22 +1235,6 @@ ILINE const Vec3_tpl<F> AngleAxis_tpl<F>::operator * (const Vec3_tpl<F>& v) cons
     return origin +  (v - origin) * cos_tpl(angle)  +  (axis % v) * sin_tpl(angle);
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 //////////////////////////////////////////////////////////////////////
 template<typename F>
 struct Plane_tpl
@@ -1405,8 +1364,6 @@ struct Plane_tpl
 };
 
 typedef Plane_tpl<f32>  Plane; //always 32 bit
-typedef Plane_tpl<f64>  Planed;//always 64 bit
-typedef Plane_tpl<real> Planer;//variable float precision. depending on the target system it can be between 32, 64 or 80 bit
 
 
 // declare common constants.  Must be done after the class for compiler conformance

Code/Legacy/CryCommon/Cry_Vector4.h

@@ -5,37 +5,31 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
-
 // Description : Common vector class
-
-
 #pragma once
 
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-// class Vec4_tpl
+// class Vec4
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-template <typename F>
-struct Vec4_tpl
+struct Vec4
 {
-    typedef F value_type;
+    using value_type = f32;
     enum
     {
         component_count = 4
     };
 
-    F x, y, z, w;
+    f32 x, y, z, w;
 
 #if defined(_DEBUG)
     ILINE Vec4_tpl()
     {
-        if constexpr (sizeof(F) == 4)
+        if constexpr (sizeof(f32) == 4)
         {
             uint32* p = alias_cast<uint32*>(&x);
             p[0] = F32NAN;
@@ -43,49 +37,25 @@ struct Vec4_tpl
             p[2] = F32NAN;
             p[3] = F32NAN;
         }
-        if constexpr (sizeof(F) == 8)
-        {
-            uint64* p = alias_cast<uint64*>(&x);
-            p[0] = F64NAN;
-            p[1] = F64NAN;
-            p[2] = F64NAN;
-            p[3] = F64NAN;
-        }
     }
 #else
-    ILINE Vec4_tpl() {}
+    ILINE Vec4() {}
 #endif
 
-    template<typename F2>
-    ILINE Vec4_tpl<F>& operator = (const Vec4_tpl<F2>& v1)
-    {
-        x = F(v1.x);
-        y = F(v1.y);
-        z = F(v1.z);
-        w = F(v1.w);
-        return (*this);
-    }
-
-    ILINE Vec4_tpl(F vx, F vy, F vz, F vw) { x = vx; y = vy; z = vz; w = vw; }
-    ILINE Vec4_tpl(const Vec3_tpl<F>& v, F vw) {  x = v.x; y = v.y; z = v.z; w = vw; }
-    explicit ILINE Vec4_tpl(F m) { x = y = z = w = m; }
-    ILINE Vec4_tpl(type_zero) { x = y = z = w = F(0); }
+    ILINE Vec4(f32 vx, f32 vy, f32 vz, f32 vw) { x = vx; y = vy; z = vz; w = vw; }
+    ILINE Vec4(const Vec3_tpl<f32>& v, f32 vw) {  x = v.x; y = v.y; z = v.z; w = vw; }
+    explicit ILINE Vec4(f32 m) { x = y = z = w = m; }
+    ILINE Vec4(type_zero) { x = y = z = w = f32(0); }
 
-    ILINE void operator () (F vx, F vy, F vz, F vw) { x = vx; y = vy; z = vz; w = vw; }
-    ILINE void operator () (const Vec3_tpl<F>& v, F vw) {  x = v.x; y = v.y; z = v.z; w = vw; }
+    ILINE void operator () (f32 vx, f32 vy, f32 vz, f32 vw) { x = vx; y = vy; z = vz; w = vw; }
+    ILINE void operator () (const Vec3_tpl<f32>& v, f32 vw) {  x = v.x; y = v.y; z = v.z; w = vw; }
 
-    ILINE F& operator [] (int index)          { assert(index >= 0 && index <= 3);  return ((F*)this)[index]; }
-    ILINE F operator [] (int index) const { assert(index >= 0 && index <= 3);  return ((F*)this)[index]; }
-    template <class T>
-    ILINE  Vec4_tpl(const Vec4_tpl<T>& v)
-        : x((F)v.x)
-        , y((F)v.y)
-        , z((F)v.z)
-        , w((F)v.w) { assert(this->IsValid()); }
+    ILINE f32& operator [] (int index)          { assert(index >= 0 && index <= 3);  return ((f32*)this)[index]; }
+    ILINE f32 operator [] (int index) const { assert(index >= 0 && index <= 3);  return ((f32*)this)[index]; }
 
-    ILINE Vec4_tpl& zero() { x = y = z = w = 0; return *this; }
+    ILINE Vec4& zero() { x = y = z = w = 0; return *this; }
 
-    ILINE bool IsEquivalent(const Vec4_tpl<F>& v1, F epsilon = VEC_EPSILON) const
+    ILINE bool IsEquivalent(const Vec4& v1, f32 epsilon = VEC_EPSILON) const
     {
         assert(v1.IsValid());
         assert(this->IsValid());
@@ -93,7 +63,7 @@ struct Vec4_tpl
     }
 
 
-    ILINE Vec4_tpl& operator=(const Vec4_tpl& src)
+    ILINE Vec4& operator=(const Vec4& src)
     {
         x = src.x;
         y = src.y;
@@ -102,17 +72,17 @@ struct Vec4_tpl
         return *this;
     }
 
-    ILINE Vec4_tpl<F> operator * (F k) const
+    ILINE Vec4 operator * (f32 k) const
     {
-        return Vec4_tpl<F>(x * k, y * k, z * k, w * k);
+        return Vec4(x * k, y * k, z * k, w * k);
     }
-    ILINE Vec4_tpl<F> operator / (F k) const
+    ILINE Vec4 operator / (f32 k) const
     {
-        k = (F)1.0 / k;
-        return Vec4_tpl<F>(x * k, y * k, z * k, w * k);
+        k = (f32)1.0 / k;
+        return Vec4(x * k, y * k, z * k, w * k);
     }
 
-    ILINE Vec4_tpl<F>& operator *= (F k)
+    ILINE Vec4& operator *= (f32 k)
     {
         x *= k;
         y *= k;
@@ -120,9 +90,9 @@ struct Vec4_tpl
         w *= k;
         return *this;
     }
-    ILINE Vec4_tpl<F>& operator /= (F k)
+    ILINE Vec4& operator /= (f32 k)
     {
-        k = (F)1.0 / k;
+        k = (f32)1.0 / k;
         x *= k;
         y *= k;
         z *= k;
@@ -130,7 +100,7 @@ struct Vec4_tpl
         return *this;
     }
 
-    ILINE void operator += (const Vec4_tpl<F>& v)
+    ILINE void operator += (const Vec4& v)
     {
         x += v.x;
         y += v.y;
@@ -138,7 +108,7 @@ struct Vec4_tpl
         w += v.w;
     }
 
-    ILINE void operator -= (const Vec4_tpl<F>& v)
+    ILINE void operator -= (const Vec4& v)
     {
         x -= v.x;
         y -= v.y;
@@ -147,17 +117,17 @@ struct Vec4_tpl
     }
 
 
-    ILINE F Dot (const Vec4_tpl<F>& vec2)   const
+    ILINE f32 Dot (const Vec4& vec2)   const
     {
         return x * vec2.x + y * vec2.y + z * vec2.z + w * vec2.w;
     }
 
-    ILINE F GetLength() const
+    ILINE f32 GetLength() const
     {
         return sqrt_tpl(Dot(*this));
     }
 
-    ILINE F GetLengthSquared() const
+    ILINE f32 GetLengthSquared() const
     {
         return Dot(*this);
     }
@@ -190,24 +160,24 @@ struct Vec4_tpl
     * Example:
     *  if (v0==v1) dosomething;
     */
-    ILINE bool operator==(const Vec4_tpl<F>& vec)
+    ILINE bool operator==(const Vec4& vec)
     {
         return x == vec.x && y == vec.y && z == vec.z && w == vec.w;
     }
-    ILINE bool operator!=(const Vec4_tpl<F>& vec) { return !(*this == vec); }
+    ILINE bool operator!=(const Vec4& vec) { return !(*this == vec); }
 
-    ILINE friend bool operator ==(const Vec4_tpl<F>& v0, const Vec4_tpl<F>& v1)
+    ILINE friend bool operator ==(const Vec4& v0, const Vec4& v1)
     {
         return ((v0.x == v1.x) && (v0.y == v1.y) && (v0.z == v1.z) && (v0.w == v1.w));
     }
-    ILINE friend bool operator !=(const Vec4_tpl<F>& v0, const Vec4_tpl<F>& v1) {   return !(v0 == v1);   }
+    ILINE friend bool operator !=(const Vec4& v0, const Vec4& v1) {   return !(v0 == v1);   }
 
     //! normalize the vector
     // The default Normalize function is in fact "safe". 0 vectors remain unchanged.
     ILINE void  Normalize()
     {
         assert(this->IsValid());
-        F fInvLen = isqrt_safe_tpl(x * x + y * y + z * z + w * w);
+        f32 fInvLen = isqrt_safe_tpl(x * x + y * y + z * z + w * w);
         x *= fInvLen;
         y *= fInvLen;
         z *= fInvLen;
@@ -218,61 +188,21 @@ struct Vec4_tpl
     ILINE void NormalizeFast()
     {
         assert(this->IsValid());
-        F fInvLen = isqrt_fast_tpl(x * x + y * y + z * z + w * w);
+        f32 fInvLen = isqrt_fast_tpl(x * x + y * y + z * z + w * w);
         x *= fInvLen;
         y *= fInvLen;
         z *= fInvLen;
         w *= fInvLen;
     }
-
-    ILINE void SetLerp(const Vec4_tpl<F>& p, const Vec4_tpl<F>& q, F t) { *this = p * (1.0f - t) + q * t; }
-    ILINE static Vec4_tpl<F> CreateLerp(const Vec4_tpl<F>& p, const Vec4_tpl<F>& q, F t) {    return p * (1.0f - t) + q * t; }
 };
 
-
-typedef Vec4_tpl<f32>    Vec4;  // always 32 bit
-typedef Vec4_tpl<f64>    Vec4d; // always 64 bit
-typedef Vec4_tpl<int32>  Vec4i;
-typedef Vec4_tpl<uint32> Vec4ui;
-typedef Vec4_tpl<real> Vec4r; // variable float precision. depending on the target system it can be 32, 64 or 80 bit
-
-#if defined(WIN32) || defined(WIN64) || defined(LINUX) || defined(APPLE)
-typedef Vec4_tpl<f32> Vec4A;
-#elif defined(AZ_RESTRICTED_PLATFORM)
-    #include AZ_RESTRICTED_FILE(Cry_Vector4_h)
-#endif
-
-//vector self-addition
-template<class F1, class F2>
-ILINE Vec4_tpl<F1>& operator += (Vec4_tpl<F1>& v0, const Vec4_tpl<F2>& v1)
-{
-    v0 = v0 + v1;
-    return v0;
-}
-
 //vector addition
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator + (const Vec4_tpl<F1>& v0, const Vec4_tpl<F2>& v1)
+ILINE Vec4 operator + (const Vec4& v0, const Vec4& v1)
 {
-    return Vec4_tpl<F1>(v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w);
+    return Vec4(v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w);
 }
 //vector subtraction
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator - (const Vec4_tpl<F1>& v0, const Vec4_tpl<F2>& v1)
-{
-    return Vec4_tpl<F1>(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z, v0.w - v1.w);
-}
-
-//vector multiplication
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator * (const Vec4_tpl<F1> v0, const Vec4_tpl<F2>& v1)
-{
-    return Vec4_tpl<F1>(v0.x * v1.x, v0.y * v1.y, v0.z * v1.z, v0.w * v1.w);
-}
-
-//vector division
-template<class F1, class F2>
-ILINE Vec4_tpl<F1> operator / (const Vec4_tpl<F1>& v0, const Vec4_tpl<F2>& v1)
+ILINE Vec4 operator - (const Vec4& v0, const Vec4& v1)
 {
-    return Vec4_tpl<F1>(v0.x / v1.x, v0.y / v1.y, v0.z / v1.z, v0.w / v1.w);
+    return Vec4(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z, v0.w - v1.w);
 }

Code/Legacy/CryCommon/FunctorBaseFunction.h

@@ -1,93 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Implementation of the common function template specializations.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_FUNCTORBASEFUNCTION_H
-#define CRYINCLUDE_CRYCOMMON_FUNCTORBASEFUNCTION_H
-#pragma once
-
-
-#include "IFunctorBase.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// No arguments.
-template<>
-class TFunctor<void (*)()>
-    : public IFunctorBase
-{
-public:
-    typedef void (* TFunctionType)();
-
-    TFunctor(TFunctionType pFunction)
-        : m_pfnFunction(pFunction){}
-
-    virtual void Call()
-    {
-        m_pfnFunction();
-    }
-private:
-    TFunctionType                   m_pfnFunction;
-};
-//////////////////////////////////////////////////////////////////////////
-
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// 1 argument.
-template<typename tArgument1>
-class TFunctor<void (*)(tArgument1)>
-    : public IFunctorBase
-{
-public:
-    typedef void (* TFunctionType)(tArgument1);
-
-    TFunctor(TFunctionType pFunction, tArgument1 Argument1)
-        : m_pfnFunction(pFunction)
-        , m_tArgument1(Argument1){}
-
-    virtual void Call()
-    {
-        m_pfnFunction(m_tArgument1);
-    }
-private:
-    TFunctionType                   m_pfnFunction;
-    tArgument1                      m_tArgument1;
-};
-//////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// 2 arguments.
-template<typename tArgument1, typename tArgument2>
-class TFunctor<void (*)(tArgument1, tArgument2)>
-    : public IFunctorBase
-{
-public:
-    typedef void (* TFunctionType)(tArgument1, tArgument2);
-
-    TFunctor(TFunctionType pFunction, const tArgument1& Argument1, const tArgument2& Argument2)
-        : m_pfnFunction(pFunction)
-        , m_tArgument1(Argument1)
-        , m_tArgument2(Argument2){}
-
-    virtual void Call()
-    {
-        m_pfnFunction(m_tArgument1, m_tArgument2);
-    }
-private:
-    TFunctionType                       m_pfnFunction;
-    tArgument1                          m_tArgument1;
-    tArgument2                          m_tArgument2;
-};
-//////////////////////////////////////////////////////////////////////////
-
-#endif // CRYINCLUDE_CRYCOMMON_FUNCTORBASEFUNCTION_H

Code/Legacy/CryCommon/FunctorBaseMember.h

@@ -1,97 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Implementation of the member function template specializations.
-
-#ifndef CRYINCLUDE_CRYCOMMON_FUNCTORBASEMEMBER_H
-#define CRYINCLUDE_CRYCOMMON_FUNCTORBASEMEMBER_H
-#pragma once
-
-
-#include "IFunctorBase.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// No Arguments
-template<typename tCalleeType>
-class TFunctor<void (tCalleeType::*)()>
-    : public IFunctorBase
-{
-public:
-    typedef void (tCalleeType::* TMemberFunctionType)();
-
-    TFunctor(tCalleeType* pCallee, TMemberFunctionType pMemberFunction)
-        : m_pCalee(pCallee)
-        , m_pfnMemberFunction(pMemberFunction){}
-
-    virtual void Call()
-    {
-        (m_pCalee->*m_pfnMemberFunction)();
-    }
-private:
-    tCalleeType*                        m_pCalee;
-    TMemberFunctionType         m_pfnMemberFunction;
-};
-//////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// 1 argument.
-template<typename tCalleeType, typename tArgument1>
-class TFunctor<void (tCalleeType::*)(tArgument1)>
-    : public IFunctorBase
-{
-public:
-    typedef void (tCalleeType::* TMemberFunctionType)(tArgument1);
-
-    TFunctor(tCalleeType* pCallee, TMemberFunctionType pMemberFunction, const tArgument1& Argument1)
-        : m_pCalee(pCallee)
-        , m_pfnMemberFunction(pMemberFunction)
-        , m_tArgument1(Argument1){}
-
-    virtual void Call()
-    {
-        (m_pCalee->*m_pfnMemberFunction)(m_tArgument1);
-    }
-private:
-    tCalleeType*                                    m_pCalee;
-    TMemberFunctionType                     m_pfnMemberFunction;
-    tArgument1                                      m_tArgument1;
-};
-//////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-// Return type void
-// 2 arguments.
-template<typename tCalleeType, typename tArgument1, typename tArgument2>
-class TFunctor<void (tCalleeType::*)(tArgument1, tArgument2)>
-    : public IFunctorBase
-{
-public:
-    typedef void (tCalleeType::* TMemberFunctionType)(tArgument1, tArgument2);
-
-    TFunctor(tCalleeType* pCallee, TMemberFunctionType pMemberFunction, const tArgument1& Argument1, const tArgument2& Argument2)
-        : m_pCalee(pCallee)
-        , m_pfnMemberFunction(pMemberFunction)
-        , m_tArgument1(Argument1)
-        , m_tArgument2(Argument2){}
-
-    virtual void Call()
-    {
-        (m_pCalee->*m_pfnMemberFunction)(m_tArgument1, m_tArgument2);
-    }
-private:
-    tCalleeType*                                    m_pCalee;
-    TMemberFunctionType                     m_pfnMemberFunction;
-    tArgument1                                      m_tArgument1;
-    tArgument2                                      m_tArgument2;
-};
-//////////////////////////////////////////////////////////////////////////
-
-#endif // CRYINCLUDE_CRYCOMMON_FUNCTORBASEMEMBER_H

Code/Legacy/CryCommon/IConsole.h

@@ -10,15 +10,13 @@
 
 #include <CryCommon/platform.h>
 #include <AzCore/std/containers/vector.h>
+#include <AzCore/std/function/function_template.h>
 #include <AzCore/std/string/string_view.h>
 
-struct SFunctor;
-
 struct ConsoleBind;
 
 struct ICVar;
 class ITexture;
-class ICrySizer;
 struct ISystem;
 
 #define     CVAR_INT              1
@@ -192,15 +190,6 @@ struct IConsole
     // Return:
     //   pointer to the interface ICVar
     virtual ICVar* RegisterInt(const char* sName, int iValue, int nFlags, const char* help = "", ConsoleVarFunc pChangeFunc = 0) = 0;
-    // Create a new console variable that store the value in a int64
-    // Arguments:
-    //   sName - console variable name
-    //   iValue - default value
-    //   nFlags - user defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data)
-    //   help - help text that is shown when you use <sName> ? in the console
-    // Return:
-    //   pointer to the interface ICVar
-    virtual ICVar* RegisterInt64(const char* sName, int64 iValue, int nFlags, const char* help = "", ConsoleVarFunc pChangeFunc = 0) = 0;
     // Create a new console variable that store the value in a float
     // Arguments:
     //   sName - console variable name
@@ -243,14 +232,6 @@ struct IConsole
     //   pointer to the interface ICVar
     virtual ICVar* Register(const char* name, const char** src, const char* defaultvalue, int nFlags = 0, const char* help = "", ConsoleVarFunc pChangeFunc = 0, bool allowModify = true) = 0;
 
-    // Registers an existing console variable
-    // Should only be used with static duration objects, object is never freed
-    // Arguments:
-    //   pVar - the existing console variable
-    // Return:
-    //   pointer to the interface ICVar (that was passed in)
-    virtual ICVar* Register(ICVar* pVar) = 0;
-
     // ! Remove a variable from the console
     // @param sVarName console variable name
     // @param bDelete if true the variable is deleted
@@ -431,9 +412,6 @@ struct IConsole
     virtual void ResetAutoCompletion() = 0;
     //////////////////////////////////////////////////////////////////////////
 
-    // Calculation of the memory used by the whole console system
-    virtual void GetMemoryUsage (ICrySizer* pSizer) const = 0;
-
     // Function related to progress bar
     virtual void ResetProgressBar(int nProgressRange) = 0;
     // Function related to progress bar
@@ -619,16 +597,12 @@ struct ICVar
     // Adds a new on change functor to the list.
     // It will add from index 1 on (0 is reserved).
     // Returns an ID to use when getting or removing the functor
-    virtual uint64 AddOnChangeFunctor(const SFunctor& pChangeFunctor) = 0;
+    virtual uint64 AddOnChangeFunctor(const AZStd::function<void()>& pChangeFunctor) = 0;
 
     //////////////////////////////////////////////////////////////////////////
     // Get the current callback function.
     virtual ConsoleVarFunc GetOnChangeCallback() const = 0;
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    //
-    virtual void GetMemoryUsage(class ICrySizer* pSizer) const = 0;
-
     //////////////////////////////////////////////////////////////////////////
     // only useful for CVarGroups, other types return GetIVal()
     // CVarGroups set multiple other CVars and this function returns

Code/Legacy/CryCommon/IEntityRenderState.h

@@ -7,33 +7,14 @@
  */
 
 #pragma once
+#include <CryCommon/Cry_Matrix34.h>
 
-#include "IStatObj.h"
-
-#include <IRenderer.h>
-#include <limits>
-#include <AzCore/Component/EntityId.h>
-#include <AzCore/std/algorithm.h>
-
-
-namespace AZ
-{
-    class Vector2;
-}
-
-struct IMaterial;
-struct IRenderNode;
-struct IVisArea;
-struct SRenderingPassInfo;
-struct SRendItemSorter;
-struct SFrameLodInfo;
-struct pe_params_area;
-struct pe_articgeomparams;
+struct IStatObj;
 
 struct IRenderNode
 {
     // Gives access to object components.
-    struct IStatObj* GetEntityStatObj(unsigned int  = 0, unsigned int  = 0, Matrix34A*  = NULL, bool  = false) {
+    IStatObj* GetEntityStatObj(unsigned int  = 0, unsigned int  = 0, Matrix34* = nullptr, bool  = false) {
         return nullptr;
     }
 

Code/Legacy/CryCommon/IFont.h

@@ -23,7 +23,6 @@
 #include <AzCore/EBus/EBus.h>
 
 struct ISystem;
-class ICrySizer;
 
 struct ICryFont;
 struct IFFont;
@@ -94,9 +93,6 @@ struct ICryFont
     //! \param glyphSizeY   Height (in pixels) of the characters to be rendered at in the font texture.
     virtual void AddCharsToFontTextures(FontFamilyPtr pFontFamily, const char* pChars, int glyphSizeX = defaultGlyphSizeX, int glyphSizeY = defaultGlyphSizeY) = 0;
 
-    // Summary:
-    //   Puts the objects used in this module into the sizer interface
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
     // Summary:
     //   All font names separated by ,
     // Example:
@@ -266,10 +262,6 @@ struct IFFont
     //   Wraps text based on specified maximum line width (UTF-8)
     virtual void WrapText(AZStd::string& result, float maxWidth, const char* pStr, const STextDrawContext& ctx) = 0;
 
-    // Description:
-    //   Puts the memory used by this font into the given sizer.
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
-
     // Description:
     //   useful for special feature rendering interleaved with fonts (e.g. box behind the text)
     virtual void GetGradientTextureCoord(float& minU, float& minV, float& maxU, float& maxV) const = 0;

Code/Legacy/CryCommon/IIndexedMesh.h

@@ -10,13 +10,8 @@
 #pragma once
 
 #include "Cry_Color.h"
-#include "StlUtils.h"
-#include "CryEndian.h"
-
-#include <Cry_Geo.h>    // for AABB
 #include <VertexFormats.h>
 #include <Vertex.h>
-#include <AzCore/Casting/numeric_cast.h>
 
 // Description:
 //    2D Texture coordinates used by CMesh.
@@ -28,32 +23,6 @@ private:
     float s, t;
 
 public:
-    explicit SMeshTexCoord(float x, float y)
-    {
-        s = x;
-        t = y;
-    }
-
-    explicit SMeshTexCoord(const Vec2f16& other)
-    {
-        const Vec2 uv = other.ToVec2();
-
-        s = uv.x;
-        t = uv.y;
-    }
-
-    explicit SMeshTexCoord(const Vec2& other)
-    {
-        s = other.x;
-        t = other.y;
-    }
-
-    explicit SMeshTexCoord(const Vec4& other)
-    {
-        s = other.x;
-        t = other.y;
-    }
-
     bool IsEquivalent(const SMeshTexCoord& other, float epsilon = 0.00005f) const
     {
         return
@@ -113,16 +82,6 @@ public:
 
 };
 
-
-struct SMeshBoneMapping_uint8
-{
-    typedef uint8 BoneId;
-    typedef uint8 Weight;
-
-    BoneId boneIds[4];
-    Weight weights[4];
-};
-
 // Subset of mesh is a continuous range of vertices and indices that share same material.
 struct SMeshSubset
 {
@@ -181,7 +140,6 @@ struct IIndexedMesh
         int m_nIndexCount; // number of elements in m_pIndices array
     };
 
-    // <interfuscator:shuffle>
     virtual ~IIndexedMesh() {}
 
     // Release indexed mesh.
@@ -190,15 +148,9 @@ struct IIndexedMesh
     //! Gives read-only access to mesh data
     virtual void GetMeshDescription(SMeshDescription& meshDesc) const = 0;
 
-    /*! Frees vertex and face streams. Calling this function invalidates SMeshDescription pointers */
-    virtual void FreeStreams() = 0;
-
     //! Return number of allocated faces
     virtual int GetFaceCount() const = 0;
 
-    /*! Reallocates faces. Calling this function invalidates SMeshDescription pointers */
-    virtual void SetFaceCount(int nNewCount) = 0;
-
     //! Return number of allocated vertices, normals and colors
     virtual int GetVertexCount() const = 0;
 
@@ -216,6 +168,4 @@ struct IIndexedMesh
     //////////////////////////////////////////////////////////////////////////
     virtual int GetSubSetCount() const = 0;
     virtual const SMeshSubset& GetSubSet(int nIndex) const = 0;
-
-    // </interfuscator:shuffle>
 };

Code/Legacy/CryCommon/ILevelSystem.h

@@ -8,13 +8,8 @@
 
 
 // Description : Gathers level information. Loads a level.
-
-
-#ifndef CRYINCLUDE_CRYACTION_ILEVELSYSTEM_H
-#define CRYINCLUDE_CRYACTION_ILEVELSYSTEM_H
 #pragma once
 
-#include <CrySizer.h>
 #include <IXml.h>
 #include <AzCore/Asset/AssetCommon.h>
 
@@ -56,8 +51,6 @@ struct ILevelSystemListener
     virtual void OnLoadingProgress([[maybe_unused]] const char* levelName, [[maybe_unused]] int progressAmount) {}
     //! Called after a level is unloaded, before the data is freed.
     virtual void OnUnloadComplete([[maybe_unused]] const char* levelName) {}
-
-    void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const { }
 };
 
 struct ILevelSystem
@@ -95,5 +88,3 @@ protected:
 
     static constexpr const char* LevelsDirectoryName = "levels";
 };
-
-#endif // CRYINCLUDE_CRYACTION_ILEVELSYSTEM_H

Code/Legacy/CryCommon/ILocalizationManager.h

@@ -43,10 +43,6 @@ struct SLocalizedAdvancesSoundEntry
 {
     AZStd::string sName;
     float       fValue;
-    void GetMemoryUsage(ICrySizer* pSizer) const
-    {
-        pSizer->AddObject(sName);
-    }
 };
 
 // Localization Sound Info structure, containing sound related parameters.

Code/Legacy/CryCommon/ILog.h

@@ -16,9 +16,6 @@
 // this code is disable by default due it's runtime cost
 //#define SUPPORT_LOG_IDENTER
 
-// forward declarations
-class ICrySizer;
-
 // Summary:
 //   Callback interface to the ILog.
 struct ILogCallback
@@ -121,10 +118,6 @@ struct ILog
 
     virtual const char* GetModuleFilter() = 0;
 
-    // Notes:
-    //   Collect memory statistics in CrySizer
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
-
     // Asset scope strings help to figure out asset dependencies in case of asset loading errors.
     // Should not be used directly, only by using define CRY_DEFINE_ASSET_SCOPE
     // @see CRY_DEFINE_ASSET_SCOPE

Code/Legacy/CryCommon/IMaterial.h

@@ -14,7 +14,6 @@
 #include <AzCore/EBus/EBus.h>
 
 struct IShader;
-struct ISurfaceType;
 struct SShaderItem;
 
 namespace AZ
@@ -38,12 +37,7 @@ namespace AZ
 struct IMaterial
 {
     // TODO: Remove it!
-
     virtual ~IMaterial() {}
-    virtual void AddRef() = 0;
-    virtual void Release() = 0;
-
     virtual SShaderItem& GetShaderItem() = 0;
     virtual const SShaderItem& GetShaderItem() const = 0;
-
 };

Code/Legacy/CryCommon/IMovieSystem.h

@@ -6,9 +6,6 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_IMOVIESYSTEM_H
-#define CRYINCLUDE_CRYCOMMON_IMOVIESYSTEM_H
 #pragma once
 
 #include <AzCore/Component/ComponentBus.h>
@@ -255,8 +252,6 @@ struct SAnimContext
     // TODO: Mask should be stored with dynamic length
     uint32 trackMask;       //!< To update certain types of tracks only
     float startTime;        //!< The start time of this playing sequence
-
-    void Serialize(XmlNodeRef& xmlNode, bool loading);
 };
 
 /** Parameters for cut-scene cameras
@@ -891,7 +886,6 @@ struct ITrackEventListener
     //      event - Track event added
     //      pUserData - Data to accompany reason
     virtual void OnTrackEvent(IAnimSequence* sequence, int reason, const char* event, void* pUserData) = 0;
-    virtual void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{};
     // </interfuscator:shuffle>
 };
 
@@ -1152,8 +1146,6 @@ struct IMovieListener
     //! callback on movie events
     virtual void OnMovieEvent(EMovieEvent movieEvent, IAnimSequence* pAnimSequence) = 0;
     // </interfuscator:shuffle>
-
-    void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
 };
 
 /** Movie System interface.
@@ -1326,7 +1318,6 @@ struct IMovieSystem
     virtual bool IsRecording() const = 0;
 
     virtual void EnableCameraShake(bool bEnabled) = 0;
-    virtual bool IsCameraShakeEnabled() const = 0;
 
     // Pause any playing sequences.
     virtual void Pause() = 0;
@@ -1381,8 +1372,6 @@ struct IMovieSystem
     virtual void EnableBatchRenderMode(bool bOn) = 0;
     virtual bool IsInBatchRenderMode() const = 0;
 
-    virtual ILightAnimWrapper* CreateLightAnimWrapper(const char* name) const = 0;
-
     virtual void LoadParamTypeFromXml(CAnimParamType& animParamType, const XmlNodeRef& xmlNode, const uint version) = 0;
     virtual void SaveParamTypeToXml(const CAnimParamType& animParamType, XmlNodeRef& xmlNode) = 0;
 
@@ -1408,40 +1397,6 @@ struct IMovieSystem
     // </interfuscator:shuffle>
 };
 
-inline void SAnimContext::Serialize(XmlNodeRef& xmlNode, bool bLoading)
-{
-    if (bLoading)
-    {
-        XmlString name;
-        if (xmlNode->getAttr("sequence", name))
-        {
-            sequence = gEnv->pMovieSystem->FindLegacySequenceByName(name.c_str());
-        }
-        xmlNode->getAttr("dt", dt);
-        xmlNode->getAttr("fps", fps);
-        xmlNode->getAttr("time", time);
-        xmlNode->getAttr("bSingleFrame", singleFrame);
-        xmlNode->getAttr("bResetting", resetting);
-        xmlNode->getAttr("trackMask", trackMask);
-        xmlNode->getAttr("startTime", startTime);
-    }
-    else
-    {
-        if (sequence)
-        {
-            AZStd::string fullname = sequence->GetName();
-            xmlNode->setAttr("sequence", fullname.c_str());
-        }
-        xmlNode->setAttr("dt", dt);
-        xmlNode->setAttr("fps", fps);
-        xmlNode->setAttr("time", time);
-        xmlNode->setAttr("bSingleFrame", singleFrame);
-        xmlNode->setAttr("bResetting", resetting);
-        xmlNode->setAttr("trackMask", trackMask);
-        xmlNode->setAttr("startTime", startTime);
-    }
-}
-
 inline void CAnimParamType::SaveToXml(XmlNodeRef& xmlNode) const
 {
     gEnv->pMovieSystem->SaveParamTypeToXml(*this, xmlNode);
@@ -1456,5 +1411,3 @@ inline void CAnimParamType::Serialize(XmlNodeRef& xmlNode, bool bLoading, const
 {
     gEnv->pMovieSystem->SerializeParamType(*this, xmlNode, bLoading, version);
 }
-
-#endif // CRYINCLUDE_CRYCOMMON_IMOVIESYSTEM_H

Code/Legacy/CryCommon/IPathfinder.h

@@ -23,6 +23,7 @@ struct IAIPathAgent;
 #include <AzCore/std/containers/vector.h>
 #include <AzCore/std/smart_ptr/shared_ptr.h>
 #include <limits>
+#include <list>
 
 // Hacks to deal with windows header inclusion.
 #ifdef GetObject

Code/Legacy/CryCommon/IReadWriteXMLSink.h

@@ -1,105 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Moved Craig's ReadWriteXMLSink from CryAction to CrySystem
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_IREADWRITEXMLSINK_H
-#define CRYINCLUDE_CRYCOMMON_IREADWRITEXMLSINK_H
-#pragma once
-
-#include <IXml.h>
-#include <AzCore/std/containers/variant.h>
-
-struct IReadXMLSink;
-struct IWriteXMLSource;
-
-struct IReadWriteXMLSink
-{
-    // <interfuscator:shuffle>
-    virtual ~IReadWriteXMLSink(){}
-    virtual bool ReadXML(const char* definitionFile, const char* dataFile, IReadXMLSink* pSink) = 0;
-    virtual bool ReadXML(const char* definitionFile, XmlNodeRef node, IReadXMLSink* pSink) = 0;
-    virtual bool ReadXML(XmlNodeRef definition, const char* dataFile, IReadXMLSink* pSink) = 0;
-    virtual bool ReadXML(XmlNodeRef definition, XmlNodeRef node, IReadXMLSink* pSink) = 0;
-
-    virtual XmlNodeRef CreateXMLFromSource(const char* definitionFile, IWriteXMLSource* pSource) = 0;
-    virtual bool WriteXML(const char* definitionFile, const char* dataFile, IWriteXMLSource* pSource) = 0;
-    // </interfuscator:shuffle>
-};
-
-
-struct SReadWriteXMLCommon
-{
-    typedef AZStd::variant<Vec3, int, float, const char*, bool> TValue;
-};
-
-
-TYPEDEF_AUTOPTR(IReadXMLSink);
-typedef IReadXMLSink_AutoPtr IReadXMLSinkPtr;
-
-// this interface allows customization of the data read routines
-struct IReadXMLSink
-    : public SReadWriteXMLCommon
-{
-    // <interfuscator:shuffle>
-    virtual ~IReadXMLSink(){}
-    // reference counting
-    virtual void AddRef() = 0;
-    virtual void Release() = 0;
-
-    virtual IReadXMLSinkPtr BeginTable(const char* name, const XmlNodeRef& definition) = 0;
-    virtual IReadXMLSinkPtr BeginTableAt(int elem, const XmlNodeRef& definition) = 0;
-    virtual bool SetValue(const char* name, const TValue& value, const XmlNodeRef& definition) = 0;
-    virtual bool EndTableAt(int elem) = 0;
-    virtual bool EndTable(const char* name) = 0;
-
-    virtual IReadXMLSinkPtr BeginArray(const char* name, const XmlNodeRef& definition) = 0;
-    virtual bool SetAt(int elem, const TValue& value, const XmlNodeRef& definition) = 0;
-    virtual bool EndArray(const char* name) = 0;
-
-    virtual bool Complete() = 0;
-
-    virtual bool IsCreationMode() = 0;
-    virtual XmlNodeRef GetCreationNode() = 0;
-    virtual void SetCreationNode(XmlNodeRef definition) = 0;
-    // </interfuscator:shuffle>
-};
-
-
-TYPEDEF_AUTOPTR(IWriteXMLSource);
-typedef IWriteXMLSource_AutoPtr IWriteXMLSourcePtr;
-
-// this interface allows customization of the data write routines
-struct IWriteXMLSource
-    : public SReadWriteXMLCommon
-{
-    // <interfuscator:shuffle>
-    virtual ~IWriteXMLSource(){}
-    // reference counting
-    virtual void AddRef() = 0;
-    virtual void Release() = 0;
-
-    virtual IWriteXMLSourcePtr BeginTable(const char* name) = 0;
-    virtual IWriteXMLSourcePtr BeginTableAt(int elem) = 0;
-    virtual bool HaveValue(const char* name) = 0;
-    virtual bool GetValue(const char* name, TValue& value, const XmlNodeRef& definition) = 0;
-    virtual bool EndTableAt(int elem) = 0;
-    virtual bool EndTable(const char* name) = 0;
-
-    virtual IWriteXMLSourcePtr BeginArray(const char* name, size_t* numElems, const XmlNodeRef& definition) = 0;
-    virtual bool HaveElemAt(int elem) = 0;
-    virtual bool GetAt(int elem, TValue& value, const XmlNodeRef& definition) = 0;
-    virtual bool EndArray(const char* name) = 0;
-
-    virtual bool Complete() = 0;
-    // </interfuscator:shuffle>
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_IREADWRITEXMLSINK_H

Code/Legacy/CryCommon/IRenderAuxGeom.h

@@ -455,7 +455,7 @@ enum EAuxGeomPublicRenderflags_DepthWrite
 //   EAuxGeomPublicRenderflagBitMasks
 enum EAuxGeomPublicRenderflags_DepthTest
 {
-    e_DepthTestOn                   = 0x0 << e_DepthTestShift,
+    e_DepthTestOn               = 0x0 << e_DepthTestShift,
     e_DepthTestOff              = 0x1 << e_DepthTestShift,
 };
 
@@ -465,10 +465,6 @@ enum EAuxGeomPublicRenderflags_Defaults
     // Default render flags for 3d primitives.
     e_Def3DPublicRenderflags = e_Mode3D | e_AlphaNone | e_DrawInFrontOff | e_FillModeSolid |
         e_CullModeBack | e_DepthWriteOn | e_DepthTestOn,
-
-    // Default render flags for 2d primitives.
-    e_Def2DPublicRenderflags = e_Mode2D | e_AlphaNone | e_DrawInFrontOff | e_FillModeSolid |
-        e_CullModeBack | e_DepthWriteOn | e_DepthTestOn
 };
 
 
@@ -487,48 +483,15 @@ struct SAuxGeomRenderFlags
     bool operator !=(const SAuxGeomRenderFlags& rhs) const;
     bool operator !=(uint32 rhs) const;
 
-    // Summary:
-    //   Gets the flags for 2D/3D rendering mode.
-    EAuxGeomPublicRenderflags_Mode2D3D GetMode2D3DFlag() const;
-    // Summary:
-    //   Sets the flags for 2D/3D rendering mode.
-    void SetMode2D3DFlag(const EAuxGeomPublicRenderflags_Mode2D3D& state);
-
-    // Summary:
-    //   Gets the flags for alpha blend mode.
-    EAuxGeomPublicRenderflags_AlphaBlendMode GetAlphaBlendMode() const;
-    // Summary:
-    //   Sets the flags for the alpha blend mode.
-    void SetAlphaBlendMode(const EAuxGeomPublicRenderflags_AlphaBlendMode& state);
-
-
-    EAuxGeomPublicRenderflags_DrawInFrontMode GetDrawInFrontMode() const;
     void SetDrawInFrontMode(const EAuxGeomPublicRenderflags_DrawInFrontMode& state);
 
-    // Summary:
-    //   Gets the flags for the filling mode.
-    EAuxGeomPublicRenderflags_FillMode GetFillMode() const;
     // Summary:
     //   Sets the flags for the filling mode.
     void SetFillMode(const EAuxGeomPublicRenderflags_FillMode& state);
 
-    // Summary:
-    //   Gets the flags for the culling mode.
-    EAuxGeomPublicRenderflags_CullMode GetCullMode() const;
     // Summary:
     //   Sets the flags for the culling mode.
     void SetCullMode(const EAuxGeomPublicRenderflags_CullMode& state);
-
-
-    EAuxGeomPublicRenderflags_DepthWrite GetDepthWriteFlag() const;
-    void SetDepthWriteFlag(const EAuxGeomPublicRenderflags_DepthWrite& state);
-
-    // Summary:
-    //   Gets the flags for the depth test.
-    EAuxGeomPublicRenderflags_DepthTest GetDepthTestFlag() const;
-    // Summary:
-    //   Sets the flags for the depth test.
-    void SetDepthTestFlag(const EAuxGeomPublicRenderflags_DepthTest& state);
 };
 
 
@@ -596,86 +559,6 @@ SAuxGeomRenderFlags::operator !=(uint32 rhs) const
 }
 
 
-inline EAuxGeomPublicRenderflags_Mode2D3D
-SAuxGeomRenderFlags::GetMode2D3DFlag() const
-{
-    int mode2D3D((int)(m_renderFlags & (uint32)e_Mode2D3DMask));
-    switch (mode2D3D)
-    {
-    case e_Mode2D:
-    {
-        return(e_Mode2D);
-    }
-    case e_Mode3D:
-    default:
-    {
-        assert(e_Mode3D == mode2D3D);
-        return(e_Mode3D);
-    }
-    }
-}
-
-
-inline void
-SAuxGeomRenderFlags::SetMode2D3DFlag(const EAuxGeomPublicRenderflags_Mode2D3D& state)
-{
-    m_renderFlags &= ~e_Mode2D3DMask;
-    m_renderFlags |= state;
-}
-
-
-inline EAuxGeomPublicRenderflags_AlphaBlendMode
-SAuxGeomRenderFlags::GetAlphaBlendMode() const
-{
-    uint32 alphaBlendMode(m_renderFlags & e_AlphaBlendingMask);
-    switch (alphaBlendMode)
-    {
-    case e_AlphaAdditive:
-    {
-        return(e_AlphaAdditive);
-    }
-    case e_AlphaBlended:
-    {
-        return(e_AlphaBlended);
-    }
-    case e_AlphaNone:
-    default:
-    {
-        assert(e_AlphaNone == alphaBlendMode);
-        return(e_AlphaNone);
-    }
-    }
-}
-
-
-inline void
-SAuxGeomRenderFlags::SetAlphaBlendMode(const EAuxGeomPublicRenderflags_AlphaBlendMode& state)
-{
-    m_renderFlags &= ~e_AlphaBlendingMask;
-    m_renderFlags |= state;
-}
-
-
-inline EAuxGeomPublicRenderflags_DrawInFrontMode
-SAuxGeomRenderFlags::GetDrawInFrontMode() const
-{
-    uint32 drawInFrontMode(m_renderFlags & e_DrawInFrontMask);
-    switch (drawInFrontMode)
-    {
-    case e_DrawInFrontOff:
-    {
-        return(e_DrawInFrontOff);
-    }
-    case e_DrawInFrontOn:
-    default:
-    {
-        assert(e_DrawInFrontOn == drawInFrontMode);
-        return(e_DrawInFrontOn);
-    }
-    }
-}
-
-
 inline void
 SAuxGeomRenderFlags::SetDrawInFrontMode(const EAuxGeomPublicRenderflags_DrawInFrontMode& state)
 {
@@ -683,31 +566,6 @@ SAuxGeomRenderFlags::SetDrawInFrontMode(const EAuxGeomPublicRenderflags_DrawInFr
     m_renderFlags |= state;
 }
 
-
-inline EAuxGeomPublicRenderflags_FillMode
-SAuxGeomRenderFlags::GetFillMode() const
-{
-    uint32 fillMode(m_renderFlags & e_FillModeMask);
-    switch (fillMode)
-    {
-    case e_FillModePoint:
-    {
-        return(e_FillModePoint);
-    }
-    case e_FillModeWireframe:
-    {
-        return(e_FillModeWireframe);
-    }
-    case e_FillModeSolid:
-    default:
-    {
-        assert(e_FillModeSolid == fillMode);
-        return(e_FillModeSolid);
-    }
-    }
-}
-
-
 inline void
 SAuxGeomRenderFlags::SetFillMode(const EAuxGeomPublicRenderflags_FillMode& state)
 {
@@ -715,117 +573,9 @@ SAuxGeomRenderFlags::SetFillMode(const EAuxGeomPublicRenderflags_FillMode& state
     m_renderFlags |= state;
 }
 
-
-inline EAuxGeomPublicRenderflags_CullMode
-SAuxGeomRenderFlags::GetCullMode() const
-{
-    uint32 cullMode(m_renderFlags & e_CullModeMask);
-    switch (cullMode)
-    {
-    case e_CullModeNone:
-    {
-        return(e_CullModeNone);
-    }
-    case e_CullModeFront:
-    {
-        return(e_CullModeFront);
-    }
-    case e_CullModeBack:
-    default:
-    {
-        assert(e_CullModeBack == cullMode);
-        return(e_CullModeBack);
-    }
-    }
-}
-
-
 inline void
 SAuxGeomRenderFlags::SetCullMode(const EAuxGeomPublicRenderflags_CullMode& state)
 {
     m_renderFlags &= ~e_CullModeMask;
     m_renderFlags |= state;
 }
-
-
-inline EAuxGeomPublicRenderflags_DepthWrite
-SAuxGeomRenderFlags::GetDepthWriteFlag() const
-{
-    uint32 depthWriteFlag(m_renderFlags & e_DepthWriteMask);
-    switch (depthWriteFlag)
-    {
-    case e_DepthWriteOff:
-    {
-        return(e_DepthWriteOff);
-    }
-    case e_DepthWriteOn:
-    default:
-    {
-        assert(e_DepthWriteOn == depthWriteFlag);
-        return(e_DepthWriteOn);
-    }
-    }
-}
-
-
-inline void
-SAuxGeomRenderFlags::SetDepthWriteFlag(const EAuxGeomPublicRenderflags_DepthWrite& state)
-{
-    m_renderFlags &= ~e_DepthWriteMask;
-    m_renderFlags |= state;
-}
-
-
-inline EAuxGeomPublicRenderflags_DepthTest
-SAuxGeomRenderFlags::GetDepthTestFlag() const
-{
-    uint32 depthTestFlag(m_renderFlags & e_DepthTestMask);
-    switch (depthTestFlag)
-    {
-    case e_DepthTestOff:
-    {
-        return(e_DepthTestOff);
-    }
-    case e_DepthTestOn:
-    default:
-    {
-        assert(e_DepthTestOn == depthTestFlag);
-        return(e_DepthTestOn);
-    }
-    }
-}
-
-
-inline void
-SAuxGeomRenderFlags::SetDepthTestFlag(const EAuxGeomPublicRenderflags_DepthTest& state)
-{
-    m_renderFlags &= ~e_DepthTestMask;
-    m_renderFlags |= state;
-}
-
-
-class CRenderAuxGeomRenderFlagsRestore
-{
-public:
-    explicit CRenderAuxGeomRenderFlagsRestore(IRenderAuxGeom* pRender);
-    ~CRenderAuxGeomRenderFlagsRestore();
-
-private:
-    IRenderAuxGeom* m_pRender;
-    SAuxGeomRenderFlags m_backuppedRenderFlags;
-
-    // copy-construction not supported
-    CRenderAuxGeomRenderFlagsRestore(const CRenderAuxGeomRenderFlagsRestore&);
-    CRenderAuxGeomRenderFlagsRestore& operator=(const CRenderAuxGeomRenderFlagsRestore&);
-};
-
-inline CRenderAuxGeomRenderFlagsRestore::CRenderAuxGeomRenderFlagsRestore(IRenderAuxGeom* pRender)
-{
-    m_pRender = pRender;
-    m_backuppedRenderFlags = m_pRender->GetRenderFlags();
-}
-
-inline CRenderAuxGeomRenderFlagsRestore::~CRenderAuxGeomRenderFlagsRestore()
-{
-    m_pRender->SetRenderFlags(m_backuppedRenderFlags);
-}

Code/Legacy/CryCommon/IRenderer.h

@@ -193,32 +193,3 @@ struct DynUiPrimitive : public AZStd::intrusive_slist_node<DynUiPrimitive>
     int m_numIndices = 0;
 };
 using DynUiPrimitiveList = AZStd::intrusive_slist<DynUiPrimitive, AZStd::slist_base_hook<DynUiPrimitive>>;
-
-class CLodValue
-{
-public:
-    CLodValue() = default;
-
-    CLodValue(int nLodA)
-    {
-        m_nLodA = aznumeric_caster(nLodA);
-    }
-
-    CLodValue(int nLodA, uint8 nDissolveRef, int nLodB)
-    {
-        m_nLodA = aznumeric_caster(nLodA);
-        m_nLodB = aznumeric_caster(nLodB);
-        m_nDissolveRef = nDissolveRef;
-    }
-
-    int LodA() const { return m_nLodA; }
-    int LodB() const { return m_nLodB; }
-
-    uint8 DissolveRefA() const { return m_nDissolveRef; }
-    uint8 DissolveRefB() const { return 255 - m_nDissolveRef; }
-
-private:
-    int16 m_nLodA = -1;
-    int16 m_nLodB = -1;
-    uint8 m_nDissolveRef = 0;
-};

Code/Legacy/CryCommon/ISerialize.h

@@ -6,179 +6,93 @@
  *
  */
 
-
 // Description : main header file
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_ISERIALIZE_H
-#define CRYINCLUDE_CRYCOMMON_ISERIALIZE_H
 #pragma once
 
+#include <AzCore/Math/Vector3.h>
 #include <Cry_Math.h>
 #include <IXml.h>
-#include "MiniQueue.h"
-#include <VectorMap.h>
 #include <StlUtils.h>
-#include <AzCore/Math/Vector3.h>
-#include <list>
 
+// Forward declarations
 class CTimeValue;
-// Forward template declaration
-template<class T, class U>
-class InterpolatedValue_tpl;
 
-// Unfortunately this needs to be here - should be in CryNetwork somewhere.
-struct SNetObjectID
+// this enumeration details what "kind" of serialization we are
+// performing, so that classes that want to, for instance, tailor
+// the data they present depending on where data is being written
+// to can do so
+enum class ESerializationTarget
 {
-    static const uint16 InvalidId = std::numeric_limits<uint16>::max();
-
-    SNetObjectID()
-        : id(InvalidId)
-        , salt(0) {}
-    SNetObjectID(uint16 i, uint16 s)
-        : id(i)
-        , salt(s) {}
-
-    uint16 id;
-    uint16 salt;
+    eST_SaveGame,
+};
 
-    ILINE bool operator!() const
+//////////////////////////////////////////////////////////////////////////
+// Temporary class for string serialization.
+//////////////////////////////////////////////////////////////////////////
+struct SSerializeString
+{
+    SSerializeString(){};
+    SSerializeString(const SSerializeString& src)
     {
-        return id == InvalidId;
-    }
-    typedef uint16 (SNetObjectID::* unknown_bool_type);
-    ILINE operator unknown_bool_type() const
+        m_str.assign(src.c_str());
+    };
+    explicit SSerializeString(const char* sbegin, const char* send)
+        : m_str(sbegin, send){};
+    ~SSerializeString()
     {
-        return !!(*this) ? &SNetObjectID::id : NULL;
     }
-    ILINE bool operator!=(const SNetObjectID& rhs) const
+
+    // Casting to const char*
+    SSerializeString(const char* s)
+        : m_str(s){};
+
+    SSerializeString& operator=(const SSerializeString& src)
     {
-        return !(*this == rhs);
+        m_str.assign(src.c_str());
+        return *this;
     }
-    ILINE bool operator==(const SNetObjectID& rhs) const
+    SSerializeString& operator=(const char* src)
     {
-        return id == rhs.id && salt == rhs.salt;
+        m_str.assign(src);
+        return *this;
     }
-    ILINE bool operator<(const SNetObjectID& rhs) const
+
+    bool operator!=(const SSerializeString& src)
     {
-        return id < rhs.id || (id == rhs.id && salt < rhs.salt);
+        return m_str != src.m_str;
     }
-    ILINE bool operator>(const SNetObjectID& rhs) const
+
+    size_t size() const
     {
-        return id > rhs.id || (id == rhs.id && salt > rhs.salt);
+        return m_str.size();
     }
-
-    bool IsLegal() const
+    size_t length() const
     {
-        return salt != 0;
+        return m_str.length();
     }
-
-    const char* GetText(char* tmpBuf = nullptr, size_t bufferSize = 0) const
+    const char* c_str() const
     {
-        static char singlebuf[64];
-        if (!tmpBuf)
-        {
-            tmpBuf = singlebuf;
-            bufferSize = sizeof(singlebuf);
-        }
-
-        if (id == InvalidId)
-        {
-            sprintf_s(tmpBuf, bufferSize, "<nil>");
-        }
-        else if (!salt)
-        {
-            sprintf_s(tmpBuf, bufferSize, "illegal:%d:%d", id, salt);
-        }
-        else
-        {
-            sprintf_s(tmpBuf, bufferSize, "%d:%d", id, salt);
-        }
-
-        return tmpBuf;
+        return m_str.c_str();
+    };
+    bool empty() const
+    {
+        return m_str.empty();
     }
-
-    uint32 GetAsUint32() const
+    void resize(int sz)
     {
-        return (uint32(salt) << 16) | id;
+        m_str.resize(sz);
     }
-
-    void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const { /*nothing*/}
-};
-
-// this enumeration details what "kind" of serialization we are
-// performing, so that classes that want to, for instance, tailor
-// the data they present depending on where data is being written
-// to can do so
-enum ESerializationTarget
-{
-    eST_SaveGame,
-    eST_Network,
-    eST_Script
-};
-
-// this inner class defines an interface so that OnUpdate
-// functions can be passed abstractly through to concrete
-// serialization classes
-struct ISerializeUpdateFunction
-{
-    // <interfuscator:shuffle>
-    virtual ~ISerializeUpdateFunction(){}
-    virtual void Execute() = 0;
-    // </interfuscator:shuffle>
-};
-
-// concrete implementation of IUpdateFunction for a general functor class
-template <class F_Update>
-class CSerializeUpdateFunction
-    : public ISerializeUpdateFunction
-{
-public:
-    CSerializeUpdateFunction(F_Update& update)
-        : m_rUpdate(update) {}
-
-    virtual void Execute()
+    void reserve(int sz)
     {
-        m_rUpdate();
+        m_str.reserve(sz);
     }
 
-private:
-    F_Update m_rUpdate;
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Temporary class for string serialization.
-//////////////////////////////////////////////////////////////////////////
-struct SSerializeString
-{
-    SSerializeString() {};
-    SSerializeString(const SSerializeString& src) { m_str.assign(src.c_str()); };
-    explicit SSerializeString(const char* sbegin, const char* send)
-        : m_str(sbegin, send) {};
-    ~SSerializeString() {}
-
-    // Casting to const char*
-    SSerializeString(const char* s)
-        : m_str(s) { };
-    //operator const char* () const { return m_str; }
-
-    SSerializeString& operator =(const SSerializeString& src) { m_str.assign(src.c_str()); return *this; }
-    SSerializeString& operator =(const char* src) { m_str.assign(src); return *this; }
-
-    bool operator != (const SSerializeString& src) { return m_str != src.m_str; }
-
-    size_t size() const { return m_str.size(); }
-    size_t length() const { return m_str.length(); }
-    const char* c_str() const { return m_str.c_str(); };
-    bool empty() const { return m_str.empty(); }
-    void resize(int sz) { m_str.resize(sz); }
-    void reserve(int sz) { m_str.reserve(sz); }
-
     void set_string(const AZStd::string& s)
     {
         m_str.assign(s.begin(), s.size());
     }
-    operator const AZStd::string() const {
+    operator const AZStd::string() const
+    {
         return m_str;
     }
 
@@ -195,21 +109,17 @@ struct ISerialize
 {
     static const int ENUM_POLICY_TAG = 0xe0000000;
 
-    ILINE ISerialize() {}
+    ISerialize()
+    {
+    }
 
-    // <interfuscator:shuffle>
-    virtual ~ISerialize(){}
+    virtual ~ISerialize()
+    {
+    }
 
     // this is for string values -- they need special support
-    virtual void ReadStringValue(const char* name, SSerializeString& curValue, uint32 policy = 0) = 0;
-    virtual void WriteStringValue(const char* name, SSerializeString& buffer, uint32 policy = 0) = 0;
-    // this function should be implemented to call the passed in interface
-    // if we are reading, and to not call it if we are writing
-    virtual void Update(ISerializeUpdateFunction* pUpdate) = 0;
-
-    // for network updates: notify the network engine that this value was only partially read and we
-    // should re-request an update from the server soon
-    virtual void FlagPartialRead() = 0;
+    virtual void ReadStringValue(const char* name, SSerializeString& curValue) = 0;
+    virtual void WriteStringValue(const char* name, SSerializeString& buffer) = 0;
 
     //////////////////////////////////////////////////////////////////////////
     // these functions should be implemented to deal with groups
@@ -224,43 +134,18 @@ struct ISerialize
     //////////////////////////////////////////////////////////////////////////
 
     virtual bool IsReading() const = 0;
-    virtual bool ShouldCommitValues() const = 0;
-    virtual ESerializationTarget GetSerializationTarget() const = 0;
-    virtual bool Ok() const = 0;
-    // </interfuscator:shuffle>
-
-    // declare all primitive Value() implementations
-#define SERIALIZATION_TYPE(T) \
-    virtual void Value(const char* name, T & x, uint32 policy) = 0;
-#include "SerializationTypes.h"
-#undef SERIALIZATION_TYPE
 
     // declare all primitive Value() implementations
 #define SERIALIZATION_TYPE(T) \
-    virtual void ValueWithDefault(const char* name, T & x, const T&defaultValue) = 0;
+    virtual void Value(const char* name, T& x) = 0;
 #include "SerializationTypes.h"
-    SERIALIZATION_TYPE(SSerializeString)
 #undef SERIALIZATION_TYPE
-    void Value([[maybe_unused]] const char* name, [[maybe_unused]] AZ::Vector3& x)
-    {
-    }
-    template <class B>
-    void Value(const char* name, B& x)
-    {
-        Value(name, x, 0);
-    }
-
-    template <class B>
-    void Value(const char* name, B& x, uint32 policy);
-
-    template <class B>
-    void ValueWithDefault(const char* name, B& x, const B& defaultValue);
 };
 
 // this class provides a wrapper so that ISerialize can be used much more
 // easily; it is a template so that if we need to wrap a more specific
 // ISerialize implementation we can do so easily
-template <class TISerialize>
+template<class TISerialize>
 class CSerializeWrapper
 {
 public:
@@ -276,507 +161,42 @@ public:
     // have been made to follow the trend.
 
     // the value function allows us to declare that a value needs
-    // to be serialized/deserialized; we can pass a serialization policy
-    // in order to compress the value, and an update function to allow
-    // us to be informed of when this value is changed
-    template <typename T_Value>
-    ILINE void Value(const char* szName, T_Value& value, int policy)
-    {
-        m_pSerialize->Value(szName, value, policy);
-    }
+    // to be serialized/deserialized;
 
-    template <typename T_Value>
+    template<typename T_Value>
     ILINE void Value(const char* szName, T_Value& value)
     {
         m_pSerialize->Value(szName, value);
     }
 
-    void Value(const char* szName, AZStd::string& value, int policy)
+    void Value(const char* szName, AZStd::string& value)
     {
         if (IsWriting())
         {
             SSerializeString& serializeString = SetSharedSerializeString(value);
-            m_pSerialize->WriteStringValue(szName, serializeString, policy);
+            m_pSerialize->WriteStringValue(szName, serializeString);
         }
         else
         {
-            if (GetSerializationTarget() != eST_Script)
-            {
-                value = "";
-            }
-
+            value = "";
             SSerializeString& serializeString = SetSharedSerializeString(value);
-            m_pSerialize->ReadStringValue(szName, serializeString, policy);
+            m_pSerialize->ReadStringValue(szName, serializeString);
             value = serializeString.c_str();
         }
     }
-    ILINE void Value(const char* szName, AZStd::string& value)
-    {
-        Value(szName, value, 0);
-    }
-    void Value(const char* szName, const AZStd::string& value, int policy)
+    void Value(const char* szName, const AZStd::string& value)
     {
         if (IsWriting())
         {
             SSerializeString& serializeString = SetSharedSerializeString(value);
-            m_pSerialize->WriteStringValue(szName, serializeString, policy);
+            m_pSerialize->WriteStringValue(szName, serializeString);
         }
         else
         {
             assert(0 && "This function can only be used for Writing");
         }
     }
-    ILINE void Value(const char* szName, const AZStd::string& value)
-    {
-        Value(szName, value, 0);
-    }
-    template <class T_Class, typename T_Value>
-    void Value(const char* szName, T_Class* pInst, T_Value (T_Class::* get)() const, void (T_Class::* set)(T_Value))
-    {
-        if (IsWriting())
-        {
-            T_Value temp = (pInst->*get)();
-            Value(szName, temp);
-        }
-        else
-        {
-            T_Value temp;
-            Value(szName, temp);
-            (pInst->*set)(temp);
-        }
-    }
-
-    template<class T, class TT>
-    void Value(const char* name, InterpolatedValue_tpl<T, TT>& val)
-    {
-        if (IsWriting())
-        {
-            T a = val.Get();
-            Value(name, a);
-        }
-
-        if (IsReading())
-        {
-            T a;
-            Value(name, a);
-            val.SetGoal(a);
-        }
-    }
-
-    template<class T, class TT>
-    void Value(const char* name, InterpolatedValue_tpl<T, TT>& val, int policy)
-    {
-        if (IsWriting())
-        {
-            T a = val.Get();
-            Value(name, a, policy);
-        }
-
-        if (IsReading())
-        {
-            T a;
-            Value(name, a, policy);
-            val.SetGoal(a);
-        }
-    }
 
-    bool ValueChar(const char* name, char* buffer, int len)
-    {
-        AZStd::string temp;
-        if (IsReading())
-        {
-            Value(name, temp);
-            if ((int)temp.length() > len - 1)
-            {
-                return false;       // truncated read
-            }
-            memcpy(buffer, temp.data(), temp.length() + 1);
-            buffer[len - 1] = 0;
-        }
-        else
-        {
-            temp = AZStd::string(buffer, buffer + len);
-            Value(name, temp);
-        }
-        return true;
-    }
-
-    template <typename T>
-    void ValueWithDefault(const char* name, T& x, const T& defaultValue)
-    {
-        m_pSerialize->ValueWithDefault(name, x, defaultValue);
-    }
-
-    void ValueWithDefault(const char* szName, AZStd::string& value, const AZStd::string& defaultValue)
-    {
-        static SSerializeString defaultSerializeString;
-
-        {
-            defaultSerializeString.set_string(defaultValue);
-        }
-
-        SSerializeString& serializeString = SetSharedSerializeString(value);
-        m_pSerialize->ValueWithDefault(szName, serializeString, defaultSerializeString);
-        if (IsReading())
-        {
-            value = serializeString.c_str();
-        }
-    }
-
-    template <class T_Class, typename T_Value, class T_SerializationPolicy>
-    void Value(const char* szName, T_Class* pInst, T_Value (T_Class::* get)() const, void (T_Class::* set)(T_Value),
-        const T_SerializationPolicy& policy)
-    {
-        if (IsWriting())
-        {
-            T_Value temp = (pInst->*get)();
-            Value(szName, temp, policy);
-        }
-        else
-        {
-            T_Value temp = static_cast<T_Value>(0);
-            Value(szName, temp, policy);
-            (pInst->*set)(temp);
-        }
-    }
-
-    // a value that is written by referring to a map of key/value pairs - we receive the key, and write the value
-    template <class T_Key, class T_Map>
-    void MappedValue(const char* szName, T_Key& value, const T_Map& mapper)
-    {
-        typedef typename T_Map::ValueType T_Value;
-
-        if (IsWriting())
-        {
-            T_Value write = mapper.KeyToValue(value);
-            Value(szName, write);
-        }
-        else
-        {
-            T_Value read;
-            Value(szName, read);
-            value = mapper.ValueToKey(read);
-        }
-    }
-
-#define CONTAINER_VALUE(container_type, insert_function)                                                                \
-    template <typename T_Value, class Allocator>                                                                        \
-    void Value(const char* name, container_type<T_Value, Allocator>&cont)                                               \
-    {                                                                                                                   \
-        if (!BeginOptionalGroup(name, true)) {return; }                                                                 \
-        if (IsWriting())                                                                                                \
-        {                                                                                                               \
-            uint32 count = cont.size();                                                                                 \
-            Value("Size", count);                                                                                       \
-            for (typename container_type<T_Value, Allocator>::iterator iter = cont.begin(); iter != cont.end(); ++iter) \
-            {                                                                                                           \
-                BeginGroup("i");                                                                                        \
-                T_Value value = *iter;                                                                                  \
-                Value("v", value);                                                                                      \
-                EndGroup();                                                                                             \
-            }                                                                                                           \
-        }                                                                                                               \
-        else                                                                                                            \
-        {                                                                                                               \
-            cont.clear();                                                                                               \
-            uint32 count = 0;                                                                                           \
-            Value("Size", count);                                                                                       \
-            while (count--)                                                                                             \
-            {                                                                                                           \
-                BeginGroup("i");                                                                                        \
-                T_Value temp;                                                                                           \
-                Value("v", temp);                                                                                       \
-                cont.insert_function(temp);                                                                             \
-                EndGroup();                                                                                             \
-            }                                                                                                           \
-        }                                                                                                               \
-        EndGroup();                                                                                                     \
-    }                                                                                                                   \
-    template <typename T_Value, class T_Map>                                                                            \
-    void MappedValue(const char* name, container_type<T_Value>&cont, const T_Map&mapper)                                \
-    {                                                                                                                   \
-        if (!BeginOptionalGroup(name, true)) {return; }                                                                 \
-        if (IsWriting())                                                                                                \
-        {                                                                                                               \
-            uint32 count = cont.size();                                                                                 \
-            Value("Size", count);                                                                                       \
-            for (typename container_type<T_Value>::iterator iter = cont.begin(); iter != cont.end(); ++iter)            \
-            {                                                                                                           \
-                BeginGroup("i");                                                                                        \
-                MappedValue("v", *iter, mapper);                                                                        \
-                EndGroup();                                                                                             \
-            }                                                                                                           \
-        }                                                                                                               \
-        else                                                                                                            \
-        {                                                                                                               \
-            cont.clear();                                                                                               \
-            uint32 count = 0;                                                                                           \
-            Value("Size", count);                                                                                       \
-            while (count--)                                                                                             \
-            {                                                                                                           \
-                BeginGroup("i");                                                                                        \
-                T_Value temp;                                                                                           \
-                MappedValue("v", temp, mapper);                                                                         \
-                cont.insert_function(temp);                                                                             \
-                EndGroup();                                                                                             \
-            }                                                                                                           \
-        }                                                                                                               \
-        EndGroup();                                                                                                     \
-    }
-
-#define PAIR_CONTAINER_VALUE(container_type, insert_function)                                                                                 \
-    template <typename T_Value1, typename T_Value2, class Allocator>                                                                          \
-    void Value(const char* name, container_type<std::pair<T_Value1, T_Value2>, Allocator>&cont)                                               \
-    {                                                                                                                                         \
-        if (!BeginOptionalGroup(name, true)) {return; }                                                                                       \
-        if (IsWriting())                                                                                                                      \
-        {                                                                                                                                     \
-            uint32 count = cont.size();                                                                                                       \
-            Value("Size", count);                                                                                                             \
-            for (typename container_type<std::pair<T_Value1, T_Value2>, Allocator>::iterator iter = cont.begin(); iter != cont.end(); ++iter) \
-            {                                                                                                                                 \
-                BeginGroup("i");                                                                                                              \
-                T_Value1 value1 = iter->first;                                                                                                \
-                T_Value2 value2 = iter->second;                                                                                               \
-                Value("v1", value1);                                                                                                          \
-                Value("v2", value2);                                                                                                          \
-                EndGroup();                                                                                                                   \
-            }                                                                                                                                 \
-        }                                                                                                                                     \
-        else                                                                                                                                  \
-        {                                                                                                                                     \
-            cont.clear();                                                                                                                     \
-            uint32 count = 0;                                                                                                                 \
-            Value("Size", count);                                                                                                             \
-            while (count--)                                                                                                                   \
-            {                                                                                                                                 \
-                BeginGroup("i");                                                                                                              \
-                T_Value1 temp1;                                                                                                               \
-                T_Value2 temp2;                                                                                                               \
-                Value("v1", temp1);                                                                                                           \
-                Value("v2", temp2);                                                                                                           \
-                cont.insert_function(std::pair<T_Value1, T_Value2>(temp1, temp2));                                                            \
-                EndGroup();                                                                                                                   \
-            }                                                                                                                                 \
-        }                                                                                                                                     \
-        EndGroup();                                                                                                                           \
-    }                                                                                                                                         \
-
-    CONTAINER_VALUE(std::vector, push_back);
-    CONTAINER_VALUE(std::list, push_back);
-    CONTAINER_VALUE(std::set, insert);
-    CONTAINER_VALUE(std::deque, push_back);
-
-    PAIR_CONTAINER_VALUE(std::list, push_back);
-    PAIR_CONTAINER_VALUE(std::vector, push_back);
-
-    template <typename T_Value>
-    void DummyValues(uint32 numDummyValues)
-    {
-        T_Value dummyValue;
-        for (uint32 i = 0; i < numDummyValues; ++i)
-        {
-            Value("Value", dummyValue);
-        }
-    }
-
-    template <typename T_Value, uint8 N>
-    void Value(const char* name, MiniQueue<T_Value, N>& cont)
-    {
-        if (!BeginOptionalGroup(name, true))
-        {
-            return;
-        }
-        if (IsWriting())
-        {
-            uint32 count = cont.Size();
-            Value("Size", count);
-            for (typename MiniQueue<T_Value, N>::SIterator iter = cont.Begin(); iter != cont.End(); ++iter)
-            {
-                T_Value value = *iter;
-                Value("Value", value);
-            }
-        }
-        else
-        {
-            cont.Clear();
-            uint32 count = 0;
-            Value("Size", count);
-            while (count--)
-            {
-                T_Value temp;
-                Value("Value", temp);
-                cont.Push(temp);
-            }
-        }
-        DummyValues<T_Value>(cont.Capacity() - cont.Size());
-        EndGroup();
-    }
-    template <typename T_Value, uint8 N, class T_Map>
-    void MappedValue(const char* name, MiniQueue<T_Value, N>& cont, const T_Map& mapper)
-    {
-        if (!BeginOptionalGroup(name, true))
-        {
-            return;
-        }
-        if (IsWriting())
-        {
-            uint8 count = cont.Size();
-            Value("Size", count);
-            for (typename MiniQueue<T_Value, N>::SIterator iter = cont.Begin(); iter != cont.End(); ++iter)
-            {
-                BeginGroup("i");
-                MappedValue("Value", *iter, mapper);
-                EndGroup();
-            }
-        }
-        else
-        {
-            cont.Clear();
-            uint8 count = 0;
-            Value("Size", count);
-            while (count--)
-            {
-                BeginGroup("i");
-                T_Value temp;
-                MappedValue("Value", temp, mapper);
-                cont.Push(temp);
-                EndGroup();
-            }
-        }
-        EndGroup();
-    }
-
-#define MAP_CONTAINER_VALUE(container_type)                                                                         \
-    template <typename T_Key, typename T_Value>                                                                     \
-    void Value(const char* name, container_type<T_Key, T_Value>&cont)                                               \
-    {                                                                                                               \
-        if (!BeginOptionalGroup(name, true)) {return; }                                                             \
-        if (IsWriting())                                                                                            \
-        {                                                                                                           \
-            uint32 count = (uint32)cont.size();                                                                     \
-            Value("Size", count);                                                                                   \
-            for (typename container_type<T_Key, T_Value>::iterator iter = cont.begin(); iter != cont.end(); ++iter) \
-            {                                                                                                       \
-                T_Key tempKey = iter->first;                                                                        \
-                BeginGroup("pair");                                                                                 \
-                Value("k", tempKey);                                                                                \
-                Value("v", iter->second);                                                                           \
-                EndGroup();                                                                                         \
-            }                                                                                                       \
-        }                                                                                                           \
-        else                                                                                                        \
-        {                                                                                                           \
-            cont.clear();                                                                                           \
-            uint32 count;                                                                                           \
-            Value("Size", count);                                                                                   \
-            while (count--)                                                                                         \
-            {                                                                                                       \
-                std::pair<T_Key, T_Value> temp;                                                                     \
-                BeginGroup("pair");                                                                                 \
-                Value("k", temp.first);                                                                             \
-                Value("v", temp.second);                                                                            \
-                EndGroup();                                                                                         \
-                cont.insert(temp);                                                                                  \
-            }                                                                                                       \
-        }                                                                                                           \
-        EndGroup();                                                                                                 \
-    }
-
-#define HASH_CONTAINER_VALUE(container_type)                                                                                \
-    template <typename T_Key, typename T_Value, typename T_Hash>                                                            \
-    void Value(const char* name, container_type<T_Key, T_Value, T_Hash>&cont)                                               \
-    {                                                                                                                       \
-        if (!BeginOptionalGroup(name, true)) {return; }                                                                     \
-        if (IsWriting())                                                                                                    \
-        {                                                                                                                   \
-            uint32 count = (uint32)cont.size();                                                                             \
-            Value("Size", count);                                                                                           \
-            for (typename container_type<T_Key, T_Value, T_Hash>::iterator iter = cont.begin(); iter != cont.end(); ++iter) \
-            {                                                                                                               \
-                T_Key tempKey = iter->first;                                                                                \
-                BeginGroup("pair");                                                                                         \
-                Value("k", tempKey);                                                                                        \
-                Value("v", iter->second);                                                                                   \
-                EndGroup();                                                                                                 \
-            }                                                                                                               \
-        }                                                                                                                   \
-        else                                                                                                                \
-        {                                                                                                                   \
-            cont.clear();                                                                                                   \
-            uint32 count;                                                                                                   \
-            Value("Size", count);                                                                                           \
-            while (count--)                                                                                                 \
-            {                                                                                                               \
-                AZStd::pair<T_Key, T_Value> temp;                                                                           \
-                BeginGroup("pair");                                                                                         \
-                Value("k", temp.first);                                                                                     \
-                Value("v", temp.second);                                                                                    \
-                EndGroup();                                                                                                 \
-                cont.insert(temp);                                                                                          \
-            }                                                                                                               \
-        }                                                                                                                   \
-        EndGroup();                                                                                                         \
-    }
-    MAP_CONTAINER_VALUE(std::map);
-    MAP_CONTAINER_VALUE(std::multimap);
-    MAP_CONTAINER_VALUE(VectorMap);
-
-    HASH_CONTAINER_VALUE(AZStd::unordered_map);
-
-    template <typename T_Value>
-    ILINE void EnumValue(const char* szName, T_Value& value,
-        T_Value first, T_Value last)
-    {
-        int32 nValue = int32(value) - first;
-        Value(szName, nValue, ISerialize::ENUM_POLICY_TAG | (last - first));
-        value = T_Value(nValue + first);
-    }
-    template <typename T_Value, class T_Class>
-    ILINE void EnumValue(const char* szName,
-        T_Class* pClass, T_Value (T_Class::* GetValue)() const, void (T_Class::* SetValue)(T_Value),
-        T_Value first, T_Value last)
-    {
-        bool w = IsWriting();
-        int nValue;
-        if (w)
-        {
-            nValue = int32((pClass->*GetValue)()) - first;
-        }
-        Value(szName, nValue, ISerialize::ENUM_POLICY_TAG | (last - first));
-        if (!w)
-        {
-            (pClass->*SetValue)(T_Value(nValue + first));
-        }
-    }
-    /*
-    // we can request that a functor be called whenever our values
-    // are being updated by calling this function
-    template <class F_Update>
-    ILINE void OnUpdate( F_Update& update )
-    {
-        CUpdateFunction<F_Update> func(update);
-        m_pSerialize->Update( &func );
-    }
-    template <class T>
-    ILINE void OnUpdate( T * pCls, void (T::*func)() )
-    {
-        class CFunc : public IUpdateFunction
-        {
-        public:
-            CFunc( T * pCls, void (T::*func)() ) : m_pCls(pCls), m_func(func) {}
-            virtual void Execute()
-            {
-                (m_pCls->*m_func)();
-            }
-        private:
-            T * m_pCls;
-            void (T::*m_func)();
-        };
-        CFunc ifunc( pCls, func );
-        m_pSerialize->Update( &ifunc );
-    }
-    */
     // groups help us find common data
     ILINE void BeginGroup(const char* szName)
     {
@@ -791,12 +211,6 @@ public:
         m_pSerialize->EndGroup();
     }
 
-    // fetch the serialization target
-    ILINE ESerializationTarget GetSerializationTarget() const
-    {
-        return m_pSerialize->GetSerializationTarget();
-    }
-
     ILINE bool IsWriting() const
     {
         return !m_pSerialize->IsReading();
@@ -805,27 +219,12 @@ public:
     {
         return m_pSerialize->IsReading();
     }
-    ILINE bool ShouldCommitValues() const
-    {
-        assert(m_pSerialize->IsReading());
-        return m_pSerialize->ShouldCommitValues();
-    }
-
-    ILINE bool Ok() const
-    {
-        return m_pSerialize->Ok();
-    }
 
     friend ILINE TISerialize* GetImpl(CSerializeWrapper<TISerialize> ser)
     {
         return ser.m_pSerialize;
     }
 
-    ILINE void FlagPartialRead()
-    {
-        m_pSerialize->FlagPartialRead();
-    }
-
     operator CSerializeWrapper<ISerialize>()
     {
         return CSerializeWrapper<ISerialize>(m_pSerialize);
@@ -844,65 +243,3 @@ private:
 
 // default serialize class to use!!
 typedef CSerializeWrapper<ISerialize> TSerialize;
-
-// simple struct to declare something serializable... useful for
-// exposition
-struct ISerializable
-{
-    virtual ~ISerializable(){}
-    virtual void SerializeWith(TSerialize) = 0;
-};
-
-template <class B>
-void ISerialize::Value(const char* name, B& x, uint32 policy)
-{
-    if (!BeginOptionalGroup(name, true))
-    {
-        return;
-    }
-    TSerialize  ser(this);
-    x.Serialize(ser);
-    EndGroup();
-}
-//
-//template <>
-//void ISerialize::Value(const char * name, AZ::Vector3& x, uint32 policy)
-//{
-//
-//}
-
-// Based off ValueWithDefault in SimpleSerialize.h
-template <class B>
-void ISerialize::ValueWithDefault(const char* name, B& x, const B& defaultValue)
-{
-    if (BeginOptionalGroup(name, x != defaultValue))
-    {
-        TSerialize  ser(this);
-        x.Serialize(ser);
-        EndGroup();
-    }
-    else if (IsReading())
-    {
-        x = defaultValue;
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Used to automatically Begin/End group in serialization stream
-//////////////////////////////////////////////////////////////////////////
-struct SSerializeScopedBeginGroup
-{
-    SSerializeScopedBeginGroup(TSerialize& ser, const char* sGroupName)
-    {
-        m_pSer = &ser;
-        m_pSer->BeginGroup(sGroupName);
-    }
-    ~SSerializeScopedBeginGroup()
-    {
-        m_pSer->EndGroup();
-    }
-private:
-    TSerialize* m_pSer;
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_ISERIALIZE_H

Code/Legacy/CryCommon/IShader.h

@@ -41,7 +41,6 @@ enum EEfResTextures : int // This needs a fixed size so the enum can be forward
 enum EParamType
 {
     eType_UNKNOWN,
-    eType_BYTE,
     eType_BOOL,
     eType_SHORT,
     eType_INT,
@@ -90,10 +89,6 @@ struct SShaderItem
     IRenderShaderResources* m_pShaderResources;
     int32 m_nTechnique;
     uint32 m_nPreprocessFlags;
-
-    bool Update();
-    bool RefreshResourceConstants();
-    inline struct SShaderTechnique* GetTechnique() const;
 };
 
 struct IAnimNode;

Code/Legacy/CryCommon/ISplines.h

@@ -347,8 +347,6 @@ namespace spline
                 m_c[3] = T((2.0f * v0 - 2.0f * v1 + s0 + s1) * idt * idt * idt);
             }
         }
-
-        void GetMemoryUsage(ICrySizer* pSizer) const {}
     };
 
     inline float fast_fmod(float x, float y)
@@ -410,7 +408,7 @@ namespace spline
 
     //! TCB spline key used in quaternion spline with angle axis as input.
     struct TCBAngAxisKey
-        :  public TCBSplineKey<CryQuat>
+        :  public TCBSplineKey<Quat>
     {
         float angle;
         Vec3 axis;

Code/Legacy/CryCommon/IStatObj.h

@@ -5,43 +5,14 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
-
 #pragma once
 
-#include "smartptr.h"           // TYPEDEF_AUTOPTR
-#include "IMaterial.h"
-
-// forward declarations
-//////////////////////////////////////////////////////////////////////
-struct ShadowMapFrustum;
-struct SRenderingPassInfo;
-struct SRendItemSorter;
-struct ITetrLattice;
-struct SPhysGeomArray;
-struct CStatObj;
-
-class CRenderObject;
-class CDLight;
-class IReadStream;
-class CLodValue;
-
-
-TYPEDEF_AUTOPTR(IReadStream);
-
-//! Interface to non animated object
-struct phys_geometry;
-struct IChunkFile;
-
-// General forward declaration.
-struct SMeshLodInfo;
-
-#include "Cry_Color.h"
 #include "Cry_Math.h"
 #include "Cry_Geo.h"
-#include "CrySizer.h"
+#include "IMaterial.h"
 
-#define MAX_STATOBJ_LODS_NUM 6
+// General forward declaration.
+struct SRenderingPassInfo;
 
 //////////////////////////////////////////////////////////////////////////
 // Type of static sub object.
@@ -50,184 +21,46 @@ enum EStaticSubObjectType
 {
     STATIC_SUB_OBJECT_MESH,         // This simple geometry part of the multi-sub object geometry.
     STATIC_SUB_OBJECT_HELPER_MESH,  // Special helper mesh, not rendered usually, used for broken pieces.
-    STATIC_SUB_OBJECT_POINT,
-    STATIC_SUB_OBJECT_DUMMY,
-    STATIC_SUB_OBJECT_XREF,
-    STATIC_SUB_OBJECT_CAMERA,
-    STATIC_SUB_OBJECT_LIGHT,
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Flags that can be set on static object.
-//////////////////////////////////////////////////////////////////////////
-enum EStaticObjectFlags
-{
-    STATIC_OBJECT_HIDDEN  =    BIT(0), // When set static object will not be displayed.
-    STATIC_OBJECT_CLONE     =      BIT(1), // specifies whether this object was cloned for modification
-    STATIC_OBJECT_GENERATED  = BIT(2), // tells that the object was generated procedurally (breakable obj., f.i.)
-    STATIC_OBJECT_CANT_BREAK = BIT(3), // StatObj has geometry unsuitable for procedural breaking
-    STATIC_OBJECT_DEFORMABLE = BIT(4), // StatObj can be procedurally smeared (using SmearStatObj)
-    STATIC_OBJECT_COMPOUND   = BIT(5), // StatObj has subobject meshes
-    STATIC_OBJECT_MULTIPLE_PARENTS = BIT(6), // Child StatObj referenced by several parents
-
-    // Collisions
-    STATIC_OBJECT_NO_PLAYER_COLLIDE = BIT(10),
-
-    // Special flags.
-    STATIC_OBJECT_SPAWN_ENTITY    = BIT(20), // StatObj spawns entity when broken.
-    STATIC_OBJECT_NO_AUTO_HIDEPOINTS = BIT(22), // Do not generate AI auto hide points around object if it's dynamic
-    STATIC_OBJECT_DYNAMIC                   = BIT(23), // mesh data should be kept in system memory (and yes, the name *is* an oxymoron)
 };
 
-#define HIT_NO_HIT (-1)
-#define HIT_UNKNOWN (-2)
-
-#define HIT_OBJ_TYPE_BRUSH   0
-#define HIT_OBJ_TYPE_TERRAIN 1
-#define HIT_OBJ_TYPE_VISAREA 2
-
 // used for on-CPU voxelization
-struct SRayHitTriangle
-{
-    SRayHitTriangle() { ZeroStruct(*this); }
-    Vec3 v[3];
-    Vec2 t[3];
-    ColorB c[3];
-    Vec3 n;
-    _smart_ptr<IMaterial> pMat;
-    uint8 nTriArea;
-    uint8 nOpacity;
-    uint8 nHitObjType;
-};
-
 struct SRayHitInfo
 {
     SRayHitInfo()
     {
         memset(this, 0, sizeof(*this));
-        nHitTriID = HIT_UNKNOWN;
     }
     //////////////////////////////////////////////////////////////////////////
     // Input parameters.
     Vec3    inReferencePoint;
     Ray     inRay;
-    bool    bInFirstHit;
-    bool        inRetTriangle;
-    bool    bUseCache;
-    bool    bOnlyZWrite;
-    bool    bGetVertColorAndTC;
-    float   fMaxHitDistance; // When not 0, only hits with closer distance will be registered.
-    Vec3        vTri0;
-    Vec3        vTri1;
-    Vec3        vTri2;
-    float       fMinHitOpacity;
 
     //////////////////////////////////////////////////////////////////////////
     // Output parameters.
-    float fDistance; // Distance from reference point.
     Vec3 vHitPos;
     Vec3 vHitNormal;
-    int  nHitMatID; // Material Id that was hit.
-    int  nHitTriID; // Triangle Id that was hit.
-    int  nHitSurfaceID; // Material Id that was hit.
-    struct IRenderMesh* pRenderMesh;
-    struct IStatObj* pStatObj;
-    Vec2 vHitTC;
-    Vec4 vHitColor;
-    Vec4 vHitTangent;
-    Vec4 vHitBitangent;
-    PodArray<SRayHitTriangle>* pHitTris;
-};
 
-enum EFileStreamingStatus
-{
-    ecss_NotLoaded,
-    ecss_InProgress,
-    ecss_Ready
+    // More inputs
+    bool    bInFirstHit;
+    bool    bUseCache;
 };
 
-struct SMeshBoneMapping_uint8;
-struct SSpine;
-struct SMeshColor;
-
 // Summary:
 //     Interface to hold static object data
 struct IStatObj
 {
-    //! Loading flags
-    enum ELoadingFlags
-    {
-        ELoadingFlagsPreviewMode = BIT(0),
-        ELoadingFlagsForceBreakable = BIT(1),
-        ELoadingFlagsIgnoreLoDs = BIT(2),
-        ELoadingFlagsTessellate = BIT(3), // if e_StatObjTessellation enabled
-        ELoadingFlagsJustGeometry = BIT(4), // for streaming, to avoid parsing all chunks
-    };
-
     //////////////////////////////////////////////////////////////////////////
     // SubObject
     //////////////////////////////////////////////////////////////////////////
     struct SSubObject
     {
-        SSubObject() { bShadowProxy = 0; }
-
         EStaticSubObjectType nType;
-        AZStd::string name;
-        AZStd::string properties;
-        int nParent;          // Index of the parent sub object, if there`s hierarchy between them.
-        Matrix34 tm;          // Transformation matrix.
         Matrix34 localTM;     // Local transformation matrix, relative to parent.
         IStatObj* pStatObj;   // Static object for sub part of CGF.
-        Vec3 helperSize;      // Size of the helper (if helper).
-        struct IRenderMesh* pWeights; // render mesh with a single deformation weights stream
-        unsigned int bIdentityMatrix : 1; // True if sub object matrix is identity.
-        unsigned int bHidden : 1; // True if sub object is hidden
-        unsigned int bShadowProxy : 1; // Child StatObj has 'shadowproxy' in name
-        unsigned int nBreakerJoints : 8; // number of joints that can switch this part to a broken state
-
-        void GetMemoryUsage(ICrySizer* pSizer) const
-        {
-            pSizer->AddObject(name);
-            pSizer->AddObject(properties);
-        }
     };
     //////////////////////////////////////////////////////////////////////////
 
-    // <interfuscator:shuffle>
-    // Description:
-    //     Increase the reference count of the object.
-    // Summary:
-    //     Notifies that the object is being used
-    virtual int AddRef() = 0;
-
-    // Description:
-    //     Decrease the reference count of the object. If the reference count
-    //     reaches zero, the object will be deleted from memory.
-    // Summary:
-    //     Notifies that the object is no longer needed
-    virtual int Release() = 0;
-
-    // Description:
-    //     Set static object flags.
-    // Arguments:
-    //     nFlags - flags to set, a combination of EStaticObjectFlags values.
-    virtual void SetFlags(int nFlags) = 0;
-
-    // Description:
-    //     Retrieve flags set on the static object.
-    virtual int GetFlags() const = 0;
-
-    // Sets the default object indicator
-    virtual void SetDefaultObject(bool state) = 0;
-
-    // Description:
-    //     Retrieves the internal flag m_nVehicleOnlyPhysics.
-    virtual unsigned int  GetVehicleOnlyPhysics() = 0;
-
-    // Description:
-    //     Retrieves the internal flag m_bBreakableByGame.
-    virtual unsigned int  GetBreakableByGame() = 0;
-
+    virtual ~IStatObj() {}
     // Description:
     //     Provide access to the faces, vertices, texture coordinates, normals and
     //     colors of the object used later for CRenderMesh construction.
@@ -237,86 +70,6 @@ struct IStatObj
     //     Get the object source geometry
     virtual struct IIndexedMesh* GetIndexedMesh(bool bCreateIfNone = false) = 0;
 
-    // Description:
-    //     Create an empty indexed mesh ready to be filled with data
-    //      If an indexed mesh already exists it is returned
-    // Return Value:
-    //     An empty indexed mesh or the existing indexed mesh
-    virtual struct IIndexedMesh* CreateIndexedMesh() = 0;
-
-    //! Access to rendering geometry for indoor engine ( optimized vert arrays, lists of shader pointers )
-    virtual struct IRenderMesh* GetRenderMesh() = 0;
-
-    // Description:
-    //     Sets and replaces the physical representation of the object.
-    // Arguments:
-    //       pPhysGeom - A pointer to a phys_geometry class.
-    //     nType - Pass 0 to set the physic geometry or pass 1 to set the obstruct geometry
-    // Summary:
-    //     Set the physic representation
-    virtual void SetPhysGeom(phys_geometry* pPhysGeom, int nType = 0) = 0;
-
-    virtual float GetAIVegetationRadius() const = 0;
-    virtual void SetAIVegetationRadius(float radius) = 0;
-
-    // Description:
-    //     Set default material for the geometry.
-    // Arguments:
-    //     pMaterial - A valid pointer to the material.
-    virtual void SetMaterial(_smart_ptr<IMaterial> pMaterial) = 0;
-
-    // Description:
-    //     Returns default material of the geometry.
-    // Arguments:
-    //     nType - Pass 0 to get the physic geometry or pass 1 to get the obstruct geometry
-    // Return Value:
-    //     A pointer to a phys_geometry class.
-    virtual _smart_ptr<IMaterial> GetMaterial() = 0;
-    virtual const _smart_ptr<IMaterial> GetMaterial() const = 0;
-
-    // Return Value:
-    //     A Vec3 object containing the bounding box.
-    // Summary:
-    //     Get the minimal bounding box component
-    virtual Vec3 GetBoxMin() = 0;
-
-    // Return Value:
-    //     A Vec3 object containing the bounding box.
-    // Summary:
-    //     Get the minimal bounding box component
-    virtual Vec3 GetBoxMax() = 0;
-
-    // Arguments:
-    //     Minimum bounding box component
-    // Summary:
-    //     Set the minimum bounding box component
-    virtual void    SetBBoxMax(const Vec3& vBBoxMax) = 0;
-
-    // Summary:
-    //     Get the object radius
-    // Return Value:
-    //     A float containing the radius
-    virtual float GetRadius() = 0;
-
-    // Description:
-    //     Reloads one or more component of the object. The possible flags
-    //     are FRO_SHADERS, FRO_TEXTURES and FRO_GEOMETRY.
-    // Arguments:
-    //     nFlags - One or more flag which indicate which element of the object
-    //     to reload
-    // Summary:
-    //     Reloads the object
-    virtual void Refresh(int nFlags) = 0;
-
-    // Description:
-    //     Registers the object elements into the renderer.
-    // Arguments:
-    //     rParams   - Render parameters
-    //     nLogLevel - Level of the LOD
-    // Summary:
-    //     Renders the object
-    virtual void Render(const struct SRendParams& rParams, const SRenderingPassInfo& passInfo) = 0;
-
     // Summary:
     //     Get the bounding box
     // Arguments:
@@ -324,13 +77,6 @@ struct IStatObj
     //     Maxs - Position of the top right far corner of the bounding box
     virtual AABB GetAABB() = 0;
 
-    // Summary:
-    //     Generate a random point in object.
-    // Arguments:
-    //     eForm - Object aspect to generate on (surface, volume, etc)
-    virtual float GetExtent(EGeomForm eForm) = 0;
-    virtual void GetRandomPos(PosNorm& ran, EGeomForm eForm) const = 0;
-
     // Description:
     //     Returns the LOD object, if present.
     // Arguments:
@@ -341,64 +87,6 @@ struct IStatObj
     // Summary:
     //     Get the LOD object
     virtual IStatObj* GetLodObject(int nLodLevel, bool bReturnNearest = false) = 0;
-    virtual IStatObj* GetLowestLod() = 0;
-    virtual int FindNearesLoadedLOD(int nLodIn, bool bSearchUp = false) = 0;
-    virtual int FindHighestLOD(int nBias) = 0;
-
-    virtual AZStd::string& GetFileName() = 0;
-    virtual const AZStd::string& GetFileName() const = 0;
-
-    // Summary:
-    //     Returns the filename of the object
-    // Return Value:
-    //     A null terminated string which contain the filename of the object.
-    virtual const char* GetFilePath() const = 0;
-
-    // Summary:
-    //     Set the filename of the object
-    // Arguments:
-    //     szFileName - New filename of the object
-    // Return Value:
-    //       None
-    virtual void SetFilePath(const char* szFileName) = 0;
-
-    // Description:
-    //     Will return the position of the helper named in the argument. The
-    //     helper should have been specified during the exporting process of
-    //     the cgf file.
-    // Arguments:
-    //     szHelperName - A null terminated string holding the name of the helper
-    // Return Value:
-    //     A Vec3 object which contains the position.
-    // Summary:
-    //     Gets the position of a specified helper
-    virtual Vec3 GetHelperPos(const char* szHelperName) = 0;
-
-    // Summary:
-    //     Gets the transformation matrix of a specified helper, see GetHelperPos
-    virtual const Matrix34& GetHelperTM(const char* szHelperName) = 0;
-
-    //! Tell us if the object is not found
-    virtual bool IsDefaultObject() = 0;
-
-    // Summary:
-    //     Free the geometry data
-    virtual void FreeIndexedMesh() = 0;
-
-    // Pushes the underlying tree of objects into the given Sizer object for statistics gathering
-    virtual void GetMemoryUsage(class ICrySizer* pSizer) const = 0;
-
-    //DOC-IGNORE-BEGIN
-    //! used for sprites
-    virtual float& GetRadiusVert() = 0;
-
-    //! used for sprites
-    virtual float& GetRadiusHors() = 0;
-    //DOC-IGNORE-END
-
-    // Summary:
-    //     Determines if the object has physics capabilities
-    virtual bool IsPhysicsExist() = 0;
 
     // Summary:
     //     Returns a pointer to the object
@@ -406,12 +94,6 @@ struct IStatObj
     //     A pointer to the current object, which is simply done like this "return this;"
     virtual struct IStatObj* GetIStatObj() { return this; }
 
-    // Summary:
-    //     Invalidates geometry inside IStatObj, will mark hosted IIndexedMesh as invalid.
-    // Arguments:
-    //     bPhysics - if true will also recreate physics for indexed mesh.
-    virtual void Invalidate(bool bPhysics = false, float tolerance = 0.05f) = 0;
-
     //////////////////////////////////////////////////////////////////////////
     // Interface to the Sub Objects.
     //////////////////////////////////////////////////////////////////////////
@@ -419,174 +101,10 @@ struct IStatObj
     //    Retrieve number of sub-objects.
     virtual int GetSubObjectCount() const = 0;
     // Summary:
-    //    Sets number of sub-objects.
-    virtual void SetSubObjectCount(int nCount) = 0;
-    // Summary:
     //    Retrieve sub object by index, where 0 <= nIndex < GetSubObjectCount()
-    virtual IStatObj::SSubObject* GetSubObject(int nIndex) = 0;
-    // Summary:
-    //    Check if this object is sub object of another IStatObj.
-    virtual bool IsSubObject() const = 0;
-    // Summary:
-    //    Retrieve parent static object, only relevant when this IStatObj is Sub-object.
-    virtual IStatObj* GetParentObject() const = 0;
-    // Summary:
-    //    Retrieve the static object, from which this one was cloned (if that is the case)
-    virtual IStatObj* GetCloneSourceObject() const = 0;
-    // Summary:
-    //    Find sub-pbject by name.
-    virtual IStatObj::SSubObject* FindSubObject(const char* sNodeName) = 0;
-    //    Find sub-object by name (including spaces, comma and semi-colon.
-    virtual IStatObj::SSubObject* FindSubObject_CGA(const char* sNodeName) = 0;
-
-    // Summary:
-    //    Find object by full name (use all the characters)
-    virtual IStatObj::SSubObject* FindSubObject_StrStr(const char* sNodeName) = 0;
-    //    Remove Sub-Object.
-    virtual bool RemoveSubObject(int nIndex) = 0;
-    //    Copy Sub-Object.
-    virtual bool CopySubObject(int nToIndex, IStatObj* pFromObj, int nFromIndex) = 0;
-    //    adds a new sub object
-    virtual IStatObj::SSubObject& AddSubObject(IStatObj* pStatObj) = 0;
-
-    virtual bool IsDeformable() = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Save contents of static object to the CGF file.
-    //////////////////////////////////////////////////////////////////////////
-    // Save object to the CGF file.
-    // Arguments:
-    //    sFilename
-    //          Filename of the CGF file.
-    //          Note that the function fails if pOutChunkFile is NULL and the path
-    //          to the file does not exist on the drive. You can call
-    //          CFileUtil::CreatePath() before SaveToCGF() call to create all
-    //          folders that do not exist yet.
-    //    pOutChunkFile
-    //          Optional output parameter. If it is specified then the file will not be written to
-    //          the drive but instead the function returns a pointer to the IChunkFile interface with
-    //          filled CGF chunks. Caller of the function is responsible to call Release method
-    //          of IChunkFile to release it later.
-    virtual bool SaveToCGF(const char* sFilename, IChunkFile** pOutChunkFile = NULL, bool bHavePhysicalProxy = false) = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Summary:
-    //    Clones static geometry, Makes an exact copy of the Static object and the contained geometry.
-    //virtual IStatObj* Clone(bool bCloneChildren=true, bool nDynamic=false) = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Summary:
-    //    Clones static geometry, Makes an exact copy of the Static object and the contained geometry.
-    virtual IStatObj* Clone(bool bCloneGeometry, bool bCloneChildren, bool bMeshesOnly) = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Summary:
-    //    makes sure that both objects have one-to-one vertex correspondance
-    //    sets MorphBuddy for this object's render mesh
-    //    returns 0 if failed (due to objects having no vertex maps most likely)
-    virtual int SetDeformationMorphTarget(IStatObj* pDeformed) = 0;
-
-    // chages the weights of the deformation morphing according to point, radius, and strength
-    // (radius==0 updates all weights of all vertices)
-    //  if the object is a compound object, updates the weights of its subobjects that have deformation morphs; clones the object if necessary
-    //   otherwise, updates the weights passed as a pWeights param
-    virtual IStatObj* DeformMorph(const Vec3& pt, float r, float strength, IRenderMesh* pWeights = 0) = 0;
-
-    // hides all non-physicalized geometry, clones the object if necessary
-    virtual IStatObj* HideFoliage() = 0;
-
-    // Get object properties as loaded from CGF.
-    virtual const char* GetProperties() = 0;
-
-    // Get physical properties specified for object.
-    virtual bool GetPhysicalProperties(float& mass, float& density) = 0;
-
-    // Returns the last B operand for this object as A, along with its relative scale
-    virtual IStatObj* GetLastBooleanOp(float& scale) = 0;
+    virtual SSubObject* GetSubObject(int nIndex) = 0;
 
     // Intersect ray with static object.
     // Ray must be in object local space.
-    virtual bool RayIntersection(SRayHitInfo& hitInfo, _smart_ptr<IMaterial> pCustomMtl = 0) = 0;
-
-    // Intersect lineseg with static object. Works on dedi server as well.
-    // Lineseg must be in object local space. Returns the hit position and the surface type id of the point hit.
-    virtual bool LineSegIntersection(const Lineseg& lineSeg, Vec3& hitPos, int& surfaceTypeId) = 0;
-
-    // Debug Draw this static object.
-    virtual void DebugDraw(const struct SGeometryDebugDrawInfo& info, float fExtrdueScale = 0.01f) = 0;
-
-    // Returns initial hide mask
-    virtual uint64 GetInitialHideMask() = 0;
-
-    // Updates hide mask as new mask = (mask & maskAND) | maskOR
-    virtual uint64 UpdateInitialHideMask(uint64 maskAND = 0ul - 1ul, uint64 maskOR = 0) = 0;
-
-    // Set the filename of the mesh of the next state (for example damaged version)
-    virtual void SetStreamingDependencyFilePath(const char* szFileName) = 0;
-
-    virtual void ComputeGeometricMean(SMeshLodInfo& lodInfo) = 0;
-
-    // Returns the distance for the first LOD switch. Used for brushes and vegetation.
-    virtual float GetLodDistance() const = 0;
-
-    // Returns true if the mesh has been stripped
-    virtual bool IsMeshStrippedCGF() const = 0;
-
-    virtual void LoadLowLODs(bool bUseStreaming, unsigned long nLoadingFlags) = 0;
-
-    // Indicates if lods have been loaded
-    virtual bool AreLodsLoaded() const = 0;
-
-    // Indicates if a garbage check should be done
-    virtual bool CheckGarbage() const = 0;
-
-    // Sets state of check garbage flags
-    virtual void SetCheckGarbage(bool val) = 0;
-
-    // Returns the number of child references
-    virtual int CountChildReferences() const = 0;
-
-    // Returns the user count
-    virtual int GetUserCount() const = 0;
-
-    // Shutdown
-    virtual void ShutDown() = 0;
-
-    virtual int GetMaxUsableLod() const = 0;
-    virtual int GetMinUsableLod() const = 0;
-
-    virtual SMeshBoneMapping_uint8* GetBoneMapping() const = 0;
-
-    virtual int GetSpineCount() const = 0;
-    virtual SSpine* GetSpines() const = 0;
-
-    virtual IStatObj* GetLodLevel0() = 0;
-    virtual void SetLodLevel0(IStatObj* lod) = 0;
-    virtual _smart_ptr<CStatObj>* GetLods() = 0;
-    virtual int GetLoadedLodsNum() = 0;
-
-    virtual bool UpdateStreamableComponents(float fImportance, const Matrix34A& objMatrix, bool bFullUpdate, int nNewLod) = 0;
-
-    virtual SPhysGeomArray& GetArrPhysGeomInfo() = 0;
-    virtual bool IsLodsAreLoadedFromSeparateFile() = 0;
-
-    virtual void StartStreaming(bool bFinishNow, IReadStream_AutoPtr* ppStream) = 0;
-    virtual void UpdateStreamingPrioriryInternal(const Matrix34A& objMatrix, float fDistance, bool bFullUpdate) = 0;
-
-    virtual void SetMerged(bool state) = 0;
-
-    virtual int GetRenderMeshMemoryUsage() const = 0;
-    virtual void SetLodObject(int nLod, IStatObj* pLod) = 0;
-    virtual int GetLoadedTrisCount() const = 0;
-    virtual int GetRenderTrisCount() const = 0;
-    virtual int GetRenderMatIds() const = 0;
-
-    virtual bool IsUnmergable() const = 0;
-    virtual void SetUnmergable(bool state) = 0;
-
-    virtual int GetSubObjectMeshCount() const = 0;
-    virtual void SetSubObjectMeshCount(int count) = 0;
-    virtual void CleanUnusedLods() = 0;
-
-    virtual AZStd::vector<SMeshColor>& GetClothData() = 0;
+    virtual bool RayIntersection(SRayHitInfo& hitInfo, IMaterial* pCustomMtl = nullptr) = 0;
 };

Code/Legacy/CryCommon/ISurfaceType.h

@@ -1,244 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Defines interfaces to access Surface Types.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_ISURFACETYPE_H
-#define CRYINCLUDE_CRYCOMMON_ISURFACETYPE_H
-#pragma once
-
-//////////////////////////////////////////////////////////////////////////
-// Flags that ISurfaceType::GetFlags() can return.
-//////////////////////////////////////////////////////////////////////////
-enum ESurfaceTypeFlags
-{
-    SURFACE_TYPE_NO_PHYSICALIZE         = BIT(1), // This surface should not be physicalized.
-    SURFACE_TYPE_NO_COLLIDE             = BIT(2), // Should only be set for vegetation canopy mats
-    SURFACE_TYPE_VEHICLE_ONLY_COLLISION = BIT(3),
-    SURFACE_TYPE_CAN_SHATTER            = BIT(4), // This surface type can shatter
-    SURFACE_TYPE_BULLET_PIERCEABLE          = BIT(5), // This surface is pierceable by bullets (used by MFX system to spawn front/back FX)
-};
-
-// Parameter structure passed to ISurfaceType::Execute
-struct SSurfaceTypeExecuteParams
-{
-    Vec3 hitPoint;
-    Vec3 hitNormal;
-    int hitType;
-};
-
-#define SURFACE_BREAKAGE_TYPE(x) x
-
-//////////////////////////////////////////////////////////////////////////
-// Surface definition.
-//////////////////////////////////////////////////////////////////////////
-struct ISurfaceType
-{
-    //////////////////////////////////////////////////////////////////////////
-    struct SSurfaceTypeAIParams
-    {
-        float fImpactRadius;
-        float fImpactSoundRadius;
-        float fFootStepRadius;
-        float proneMult;
-        float crouchMult;
-        float movingMult;
-
-        SSurfaceTypeAIParams()
-        {
-            fImpactRadius = 2.5f;
-            fImpactSoundRadius = 20.0f;
-            fFootStepRadius = 20.0f;
-            proneMult = 0.2f;
-            crouchMult = 0.5f;
-            movingMult = 2.5f;
-        }
-    };
-    struct SPhysicalParams
-    {
-        int breakable_id;
-        int break_energy;
-        float hole_size;
-        float hole_size_explosion;
-        float hit_radius;
-        float hit_points;
-        float hit_points_secondary;
-        float hit_maxdmg;
-        float hit_lifetime;
-        int pierceability;
-        float damage_reduction;
-        float ric_angle;
-        float ric_dam_reduction;
-        float ric_vel_reduction;
-        float friction;
-        float bouncyness;
-        int iBreakability;
-        int collType;
-        float sound_obstruction;
-    };
-    struct SBreakable2DParams
-    {
-        AZStd::string particle_effect;
-        float blast_radius;
-        float blast_radius_first;
-        float vert_size_spread;
-        int rigid_body;
-        float life_time;
-        float cell_size;
-        int max_patch_tris;
-        float filter_angle;
-        float shard_density;
-        int use_edge_alpha;
-        float crack_decal_scale;
-        AZStd::string crack_decal_mtl;
-        float max_fracture;
-        AZStd::string full_fracture_fx;
-        AZStd::string fracture_fx;
-        int no_procedural_full_fracture;
-        AZStd::string broken_mtl;
-        float destroy_timeout;
-        float destroy_timeout_spread;
-
-        SBreakable2DParams()
-            : blast_radius(0)
-            , rigid_body(0)
-            , life_time(0)
-            , cell_size(0)
-            , max_patch_tris(0)
-            , shard_density(0)
-            , crack_decal_scale(0)
-            , max_fracture(1.0f)
-            , vert_size_spread(0)
-            , filter_angle(0)
-            , use_edge_alpha(0)
-            , blast_radius_first(0)
-            , no_procedural_full_fracture(0)
-            , destroy_timeout(0)
-            , destroy_timeout_spread(0) {}
-    };
-    struct SBreakageParticles
-    {
-        AZStd::string type;
-        AZStd::string particle_effect;
-        int count_per_unit;
-        float count_scale;
-        float scale;
-        SBreakageParticles()
-            : count_per_unit(1)
-            , count_scale(1)
-            , scale(1) {}
-    };
-
-    // <interfuscator:shuffle>
-    virtual ~ISurfaceType(){}
-
-    // Releases surface type.
-    virtual void Release() = 0;
-
-    // Return unique Id of this surface type.
-    // Maximum of 65535 simultanious surface types can exist.
-    virtual uint16 GetId() const = 0;
-
-    // Unique name of the surface type.
-    virtual const char* GetName() const = 0;
-
-    // Typename of this surface type.
-    virtual const char* GetType() const = 0;
-
-    // Flags of the surface type.
-    // Return:
-    //    A combination of ESurfaceTypeFlags flags.
-    virtual int  GetFlags() const = 0;
-
-    // Execute material.
-    virtual void Execute(SSurfaceTypeExecuteParams& params) = 0;
-
-    // returns a some cached properties for faster access
-    virtual int GetBreakability() const = 0;
-    virtual float GetBreakEnergy() const = 0;
-    virtual int GetHitpoints() const = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    virtual const SPhysicalParams& GetPhyscalParams() = 0;
-
-    // Optional AI Params.
-    virtual const SSurfaceTypeAIParams* GetAIParams() = 0;
-
-    // Optional params for 2D breakable plane.
-    virtual SBreakable2DParams* GetBreakable2DParams() = 0;
-    virtual SBreakageParticles* GetBreakageParticles(const char* sType, bool bLookInDefault = true) = 0;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Called by Surface manager.
-    //////////////////////////////////////////////////////////////////////////
-    // Loads surface, (do not use directly).
-    virtual bool Load(int nId) = 0;
-    // </interfuscator:shuffle>
-};
-
-//////////////////////////////////////////////////////////////////////////
-// Description:
-//    This interface is used to enumerate all items registered to the surface type manager.
-//////////////////////////////////////////////////////////////////////////
-struct ISurfaceTypeEnumerator
-{
-    // <interfuscator:shuffle>
-    virtual ~ISurfaceTypeEnumerator(){}
-    virtual void Release() = 0;
-    virtual ISurfaceType* GetFirst() = 0;
-    virtual ISurfaceType* GetNext() = 0;
-    // </interfuscator:shuffle>
-};
-
-// Description:
-//    Manages loading and mapping of physical surface materials to Ids and materials scripts.
-// Behaviour:
-//    At start will enumerate all material names.
-//    When the surface is first time requested by name it will be loaded and cached
-//    and new unique id will be generated for it.
-struct ISurfaceTypeManager
-{
-    // <interfuscator:shuffle>
-    virtual ~ISurfaceTypeManager(){}
-
-
-    // Description:
-    //    Load Surface types
-    virtual void LoadSurfaceTypes() = 0;
-
-    // Description:
-    //    Return surface type by name.
-    //    If surface is not yet loaded it will be loaded and and cached.
-    // Arguments:
-    //    sName - Name of the surface type ("mat_metal","mat_wood", etc..)
-    //    warn - print warning message if surface not found
-    virtual ISurfaceType* GetSurfaceTypeByName(const char* sName, const char* sWhy = NULL, bool warn = true) = 0;
-
-    // Description:
-    //    Return surface type by id.
-    //    If surface is not yet loaded it will be loaded and and cached.
-    // Arguments:
-    //    sName - Name of the surface type ("mat_metal","mat_wood", etc..)
-    virtual ISurfaceType* GetSurfaceType(int nSurfaceId, const char* sWhy = NULL) = 0;
-
-    // Description:
-    //    Retrieve an interface to the enumerator class that allow to iterate over all surface types.
-    virtual ISurfaceTypeEnumerator* GetEnumerator() = 0;
-
-    // Register a new surface type.
-    virtual bool RegisterSurfaceType(ISurfaceType* pSurfaceType, bool bDefault = false) = 0;
-    virtual void UnregisterSurfaceType(ISurfaceType* pSurfaceType) = 0;
-
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
-    // </interfuscator:shuffle>
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_ISURFACETYPE_H
-

Code/Legacy/CryCommon/ISystem.h

@@ -6,8 +6,6 @@
  *
  */
 
-#ifndef CRYINCLUDE_CRYCOMMON_ISYSTEM_H
-#define CRYINCLUDE_CRYCOMMON_ISYSTEM_H
 #pragma once
 
 #ifdef CRYSYSTEM_EXPORTS
@@ -15,10 +13,10 @@
 #else
 #define CRYSYSTEM_API DLL_IMPORT
 #endif
+#include <AzCore/IO/SystemFile.h>
 
 #include "CryAssert.h"
-
-#include <AzCore/IO/SystemFile.h>
+#include <CryCommon/IValidator.h>
 
 #if defined(AZ_RESTRICTED_PLATFORM)
 #undef AZ_RESTRICTED_SECTION
@@ -33,7 +31,6 @@
 // Forward declarations
 ////////////////////////////////////////////////////////////////////////////////////////////////
 #include <IXml.h> // <> required for Interfuscator
-#include "IValidator.h" // <> required for Interfuscator
 #include <ILog.h> // <> required for Interfuscator
 #include "CryVersion.h"
 #include "smartptr.h"
@@ -61,9 +58,7 @@ struct SFileVersion;
 struct INameTable;
 struct ILevelSystem;
 struct IViewSystem;
-class ICrySizer;
 class IXMLBinarySerializer;
-struct IReadWriteXMLSink;
 struct IAVI_Reader;
 class CPNoise3;
 struct ILocalizationManager;
@@ -84,9 +79,11 @@ class CCamera;
 struct CLoadingTimeProfiler;
 
 class ICmdLine;
-
 class ILyShine;
 
+enum EValidatorModule : int;
+enum EValidatorSeverity : int;
+
 enum ESystemUpdateFlags
 {
     // Summary:
@@ -435,9 +432,6 @@ struct ISystemUserCallback
     //   Show message by provider.
     virtual int ShowMessage(const char* text, const char* caption, unsigned int uType) { return CryMessageBox(text, caption, uType); }
 
-    // Description:
-    //   Collects the memory information in the user program/application.
-    virtual void GetMemoryUsage(ICrySizer* pSizer) = 0;
     // </interfuscator:shuffle>
 
     //   Post console load, for cvar setting
@@ -1313,9 +1307,8 @@ namespace Detail
         const char* GetHelp() { return NULL; }
         bool IsConstCVar() const { return true; }
         void SetOnChangeCallback(ConsoleVarFunc pChangeFunc) { (void)pChangeFunc; }
-        uint64 AddOnChangeFunctor(const SFunctor& pChangeFunctor) { (void)pChangeFunctor; return 0; }
+        uint64 AddOnChangeFunctor(const AZStd::function<void()>& pChangeFunctor) { (void)pChangeFunctor; return 0; }
         ConsoleVarFunc GetOnChangeCallback() const { InvalidAccess(); return NULL; }
-        void GetMemoryUsage([[maybe_unused]] class ICrySizer* pSizer) const {}
         int GetRealIVal() const { return GetIVal(); }
         void SetLimits([[maybe_unused]] float min, [[maybe_unused]] float max) { return; }
         void GetLimits([[maybe_unused]] float& min, [[maybe_unused]] float& max) { return; }
@@ -1411,18 +1404,9 @@ static void AssertConsoleExists(void)
 //   Preferred way to register an int CVar with a callback
 #define REGISTER_INT_CB(_name, _def_val, _flags, _comment, _onchangefunction)                   (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->RegisterInt(_name, (_def_val), (_flags), CVARHELP(_comment), _onchangefunction))
 // Summary:
-//   Preferred way to register an int64 CVar
-#define REGISTER_INT64(_name, _def_val, _flags, _comment)                                                      (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->RegisterInt64(_name, (_def_val), (_flags), CVARHELP(_comment)))
-// Summary:
-//   Preferred way to register an int64 CVar with a callback
-#define REGISTER_INT64_CB(_name, _def_val, _flags, _comment, _onchangefunction)                                                     (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->RegisterInt64(_name, (_def_val), (_flags), CVARHELP(_comment), _onchangefunction))
-// Summary:
 //   Preferred way to register a float CVar
 #define REGISTER_FLOAT(_name, _def_val, _flags, _comment)                                                      (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->RegisterFloat(_name, (_def_val), (_flags), CVARHELP(_comment)))
 // Summary:
-//   Preferred way to register a float CVar with a callback
-#define REGISTER_FLOAT_CB(_name, _def_val, _flags, _comment, _onchangefunction)                 (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->RegisterFloat(_name, (_def_val), (_flags), CVARHELP(_comment), _onchangefunction))
-// Summary:
 //   Offers more flexibility but more code is required
 #define REGISTER_CVAR2(_name, _var, _def_val, _flags, _comment)                                             (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->Register(_name, _var, (_def_val), (_flags), CVARHELP(_comment)))
 // Summary:
@@ -1432,9 +1416,6 @@ static void AssertConsoleExists(void)
 //   Offers more flexibility but more code is required, explicit address taking of destination variable
 #define REGISTER_CVAR3(_name, _var, _def_val, _flags, _comment)                                             (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->Register(_name, &(_var), (_def_val), (_flags), CVARHELP(_comment)))
 // Summary:
-//   Offers more flexibility but more code is required, explicit address taking of destination variable
-#define REGISTER_CVAR3_CB(_name, _var, _def_val, _flags, _comment, _onchangefunction)    (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? 0 : gEnv->pConsole->Register(_name, &(_var), (_def_val), (_flags), CVARHELP(_comment), _onchangefunction))
-// Summary:
 //   Preferred way to register a console command
 #define REGISTER_COMMAND(_name, _func, _flags, _comment)                                                           (ASSERT_CONSOLE_EXISTS, gEnv->pConsole == 0 ? false : gEnv->pConsole->AddCommand(_name, _func, (_flags), CVARHELP(_comment)))
 // Summary:
@@ -1465,12 +1446,10 @@ static void AssertConsoleExists(void)
 #define REGISTER_STRING_CB_DEV_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)               NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)                                  /* consumed; pure cvar not available */
 #define REGISTER_INT_DEV_ONLY(_name, _def_val, _flags, _comment)                                                               NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)                                  /* consumed; pure cvar not available */
 #define REGISTER_INT_CB_DEV_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)                  NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)                                  /* consumed; pure cvar not available */
-#define REGISTER_INT64_DEV_ONLY(_name, _def_val, _flags, _comment)                                                         NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)                                  /* consumed; pure cvar not available */
 #define REGISTER_FLOAT_DEV_ONLY(_name, _def_val, _flags, _comment)                                                         NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)                                  /* consumed; pure cvar not available */
 #define REGISTER_CVAR2_DEV_ONLY(_name, _var, _def_val, _flags, _comment)                                                NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0); *(_var) = _def_val
 #define REGISTER_CVAR2_CB_DEV_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)       NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0); *(_var) = _def_val
 #define REGISTER_CVAR3_DEV_ONLY(_name, _var, _def_val, _flags, _comment)                                                NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0); _var = _def_val
-#define REGISTER_CVAR3_CB_DEV_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)       NULL; static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0); _var = _def_val
 #define REGISTER_COMMAND_DEV_ONLY(_name, _func, _flags, _comment)                                                  /* consumed; command not available */
 #else
 #define REGISTER_CVAR_DEV_ONLY(_var, _def_val, _flags, _comment)                                                               REGISTER_CVAR(_var, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
@@ -1479,12 +1458,10 @@ static void AssertConsoleExists(void)
 #define REGISTER_STRING_CB_DEV_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)               REGISTER_STRING_CB(_name, _def_val, ((_flags) | VF_DEV_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_INT_DEV_ONLY(_name, _def_val, _flags, _comment)                                                               REGISTER_INT(_name, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_INT_CB_DEV_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)                  REGISTER_INT_CB(_name, _def_val, ((_flags) | VF_DEV_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
-#define REGISTER_INT64_DEV_ONLY(_name, _def_val, _flags, _comment)                                                         REGISTER_INT64(_name, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_FLOAT_DEV_ONLY(_name, _def_val, _flags, _comment)                                                         REGISTER_FLOAT(_name, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_CVAR2_DEV_ONLY(_name, _var, _def_val, _flags, _comment)                                                REGISTER_CVAR2(_name, _var, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_CVAR2_CB_DEV_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)       REGISTER_CVAR2_CB(_name, _var, _def_val, ((_flags) | VF_DEV_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_CVAR3_DEV_ONLY(_name, _var, _def_val, _flags, _comment)                                                REGISTER_CVAR3(_name, _var, _def_val, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
-#define REGISTER_CVAR3_CB_DEV_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)       REGISTER_CVAR3_CB(_name, _var, _def_val, ((_flags) | VF_DEV_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_COMMAND_DEV_ONLY(_name, _func, _flags, _comment)                                                          REGISTER_COMMAND(_name, _func, ((_flags) | VF_DEV_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #endif // defined(_RELEASE)
 //
@@ -1508,12 +1485,9 @@ static void AssertConsoleExists(void)
 #define REGISTER_STRING_CB_DEDI_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)          REGISTER_STRING_CB(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_INT_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                          REGISTER_INT(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_INT_CB_DEDI_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)                 REGISTER_INT_CB(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
-#define REGISTER_INT64_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                        REGISTER_INT64(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_FLOAT_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                        REGISTER_FLOAT(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_CVAR2_DEDI_ONLY(_name, _var, _def_val, _flags, _comment)                                               REGISTER_CVAR2(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_CVAR2_CB_DEDI_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)  REGISTER_CVAR2_CB(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
-#define REGISTER_CVAR3_DEDI_ONLY(_name, _var, _def_val, _flags, _comment)                                               REGISTER_CVAR3(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
-#define REGISTER_CVAR3_CB_DEDI_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)  REGISTER_CVAR3_CB(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #define REGISTER_COMMAND_DEDI_ONLY(_name, _func, _flags, _comment)                                                         REGISTER_COMMAND(_name, _func, ((_flags) | VF_DEDI_ONLY), _comment); static_assert(((_flags) & ILLEGAL_DEV_FLAGS) == 0)
 #else
 #define REGISTER_CVAR_DEDI_ONLY(_var, _def_val, _flags, _comment)                                                          REGISTER_CVAR_DEV_ONLY(_var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
@@ -1522,12 +1496,9 @@ static void AssertConsoleExists(void)
 #define REGISTER_STRING_CB_DEDI_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)          REGISTER_STRING_CB_DEV_ONLY(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction)
 #define REGISTER_INT_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                          REGISTER_INT_DEV_ONLY(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
 #define REGISTER_INT_CB_DEDI_ONLY(_name, _def_val, _flags, _comment, _onchangefunction)                 REGISTER_INT_CB_DEV_ONLY(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction)
-#define REGISTER_INT64_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                        REGISTER_INT64_DEV_ONLY(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
 #define REGISTER_FLOAT_DEDI_ONLY(_name, _def_val, _flags, _comment)                                                        REGISTER_FLOAT_DEV_ONLY(_name, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
 #define REGISTER_CVAR2_DEDI_ONLY(_name, _var, _def_val, _flags, _comment)                                               REGISTER_CVAR2_DEV_ONLY(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
 #define REGISTER_CVAR2_CB_DEDI_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)  REGISTER_CVAR2_CB_DEV_ONLY(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction)
-#define REGISTER_CVAR3_DEDI_ONLY(_name, _var, _def_val, _flags, _comment)                                               REGISTER_CVAR3_DEV_ONLY(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment)
-#define REGISTER_CVAR3_CB_DEDI_ONLY(_name, _var, _def_val, _flags, _comment, _onchangefunction)  REGISTER_CVAR3_CB_DEV_ONLY(_name, _var, _def_val, ((_flags) | VF_DEDI_ONLY), _comment, _onchangefunction)
 #define REGISTER_COMMAND_DEDI_ONLY(_name, _func, _flags, _comment)                                                         REGISTER_COMMAND_DEV_ONLY(_name, _func, ((_flags) | VF_DEDI_ONLY), _comment)
 #endif // defined(_RELEASE)
 //
@@ -1592,4 +1563,3 @@ inline void CryLogAlways(const char* format, ...)
 }
 
 #endif // EXCLUDE_NORMAL_LOG
-#endif // CRYINCLUDE_CRYCOMMON_ISYSTEM_H

Code/Legacy/CryCommon/ITexture.h

@@ -13,7 +13,6 @@
 enum ETEX_Format : AZ::u8
 {
     eTF_Unknown = 0,
-    eTF_R8G8B8A8S,
     eTF_R8G8B8A8 = 2, // may be saved into file
 
     eTF_A8 = 4,
@@ -25,76 +24,6 @@ enum ETEX_Format : AZ::u8
     eTF_R8G8,
     eTF_R8G8S,
     eTF_R16G16,
-    eTF_R16G16S,
-    eTF_R16G16F,
-    eTF_R11G11B10F,
-    eTF_R10G10B10A2,
-    eTF_R16G16B16A16,
-    eTF_R16G16B16A16S,
-    eTF_R16G16B16A16F,
-    eTF_R32G32B32A32F,
-
-    eTF_CTX1,
-    eTF_BC1 = 22, // may be saved into file
-    eTF_BC2 = 23, // may be saved into file
-    eTF_BC3 = 24, // may be saved into file
-    eTF_BC4U,     // 3Dc+
-    eTF_BC4S,
-    eTF_BC5U,     // 3Dc
-    eTF_BC5S,
-    eTF_BC6UH,
-    eTF_BC6SH,
-    eTF_BC7,
-    eTF_R9G9B9E5,
-
-    // hardware depth buffers
-    eTF_D16,
-    eTF_D24S8,
-    eTF_D32F,
-    eTF_D32FS8,
-
-    // only available as hardware format under DX11.1 with DXGI 1.2
-    eTF_B5G6R5,
-    eTF_B5G5R5,
-    eTF_B4G4R4A4,
-
-    // only available as hardware format under OpenGL
-    eTF_EAC_R11,
-    eTF_EAC_RG11,
-    eTF_ETC2,
-    eTF_ETC2A,
-
-    // only available as hardware format under DX9
-    eTF_A8L8,
-    eTF_L8,
-    eTF_L8V8U8,
-    eTF_B8G8R8,
-    eTF_L8V8U8X8,
-    eTF_B8G8R8X8,
-    eTF_B8G8R8A8,
-
-    eTF_PVRTC2,
-    eTF_PVRTC4,
-
-    eTF_ASTC_4x4,
-    eTF_ASTC_5x4,
-    eTF_ASTC_5x5,
-    eTF_ASTC_6x5,
-    eTF_ASTC_6x6,
-    eTF_ASTC_8x5,
-    eTF_ASTC_8x6,
-    eTF_ASTC_8x8,
-    eTF_ASTC_10x5,
-    eTF_ASTC_10x6,
-    eTF_ASTC_10x8,
-    eTF_ASTC_10x10,
-    eTF_ASTC_12x10,
-    eTF_ASTC_12x12,
-
-    // add R16 unsigned int format for hardware that do not support float point rendering
-    eTF_R16U,
-    eTF_R16G16U,
-    eTF_R10G10B10A2UI,
 
     eTF_MaxFormat               // unused, must be always the last in the list
 };

Code/Legacy/CryCommon/IValidator.h

@@ -9,21 +9,15 @@
 
 // Description : IValidator interface used to check objects for warnings and errors
 //               Report missing resources or invalid files.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_IVALIDATOR_H
-#define CRYINCLUDE_CRYCOMMON_IVALIDATOR_H
 #pragma once
 
 #   define MAX_WARNING_LENGTH   4096
 
-#if MAX_WARNING_LENGTH < 33
-#error "MAX_WARNING_LENGTH should be bigger than 32"
-#endif
+static_assert(MAX_WARNING_LENGTH>32,"MAX_WARNING_LENGTH should be bigger than 32");
 
 #define ERROR_CANT_FIND_CENTRAL_DIRECTORY "Cannot find Central Directory Record in pak. This is either not a pak file, or a pak file without Central Directory. It does not mean that the data is permanently lost, but it may be severely damaged. Please repair the file with external tools, there may be enough information left to recover the file completely."
 
-enum EValidatorSeverity
+enum EValidatorSeverity : int
 {
     VALIDATOR_ERROR,
     VALIDATOR_ERROR_DBGBRK, // will __debugbreak() if sys_error_debugbreak is 1
@@ -31,7 +25,7 @@ enum EValidatorSeverity
     VALIDATOR_COMMENT
 };
 
-enum EValidatorModule
+enum EValidatorModule : int
 {
     VALIDATOR_MODULE_UNKNOWN,
     VALIDATOR_MODULE_RENDERER,
@@ -61,45 +55,3 @@ enum EValidatorFlags
     VALIDATOR_FLAG_IGNORE_IN_EDITOR = 0x0040, // Do not log this with the editor
     VALIDATOR_FLAG_SKIP_VALIDATOR   = 0x0080, // Do not call validator's Report()
 };
-
-struct SValidatorRecord
-{
-    //! Severity of this error.
-    EValidatorSeverity severity;
-    //! In which module error occured.
-    EValidatorModule module;
-    //! Error Text.
-    const char* text;
-    //! File which is missing or causing problem.
-    const char* file;
-    //! Additional description for this error.
-    const char* description;
-    //! Asset scope sring
-    const char* assetScope;
-    //! Flags that suggest kind of error.
-    int flags;
-
-    //////////////////////////////////////////////////////////////////////////
-    SValidatorRecord()
-    {
-        module = VALIDATOR_MODULE_UNKNOWN;
-        text = NULL;
-        file = NULL;
-        assetScope = NULL;
-        description = NULL;
-        severity = VALIDATOR_WARNING;
-        flags = 0;
-    }
-};
-
-/*! This interface will be given to Validate methods of engine, for resources and objects validation.
- */
-struct IValidator
-{
-    // <interfuscator:shuffle>
-    virtual ~IValidator(){}
-    virtual void Report(SValidatorRecord& record) = 0;
-    // </interfuscator:shuffle>
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_IVALIDATOR_H

Code/Legacy/CryCommon/IXml.h

@@ -5,18 +5,12 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_IXML_H
-#define CRYINCLUDE_CRYCOMMON_IXML_H
 #pragma once
 
 #include <platform.h>
 #include <Cry_Math.h>
 #include <AzCore/IO/FileIO.h>
 
-class ICrySizer;
-
 template <class T>
 struct Color_tpl;
 typedef Color_tpl<uint8> ColorB;
@@ -24,17 +18,12 @@ typedef Color_tpl<uint8> ColorB;
 template <typename F>
 struct Vec2_tpl;
 typedef Vec2_tpl<f32>   Vec2;
-typedef Vec2_tpl<f64>  Vec2d;
 
 template <typename F>
 struct Vec3_tpl;
 typedef Vec3_tpl<f32>   Vec3;
-typedef Vec3_tpl<f64>  Vec3d;
 
-template <typename F>
-struct Vec4_tpl;
-typedef Vec4_tpl<f32>   Vec4;
-typedef Vec4_tpl<f64>  Vec4d;
+struct Vec4;
 
 template <typename F>
 struct Quat_tpl;
@@ -59,7 +48,6 @@ class QColor;
 class QString;
 
 class IXMLBinarySerializer;
-struct IReadWriteXMLSink;
 struct ISerialize;
 
 /*
@@ -329,11 +317,9 @@ public:
     virtual void setAttr(const char* key, float value) = 0;
     virtual void setAttr(const char* key, double value) = 0;
     virtual void setAttr(const char* key, const Vec2& value) = 0;
-    virtual void setAttr(const char* key, const Vec2d& value) = 0;
     virtual void setAttr(const char* key, const Ang3& value) = 0;
     virtual void setAttr(const char* key, const Vec3& value) = 0;
     virtual void setAttr(const char* key, const Vec4& value) = 0;
-    virtual void setAttr(const char* key, const Vec3d& value) = 0;
     virtual void setAttr(const char* key, const Quat& value) = 0;
 #if defined(LINUX64) || defined(APPLE)
     // Compatibility functions, on Linux and Mac long int is the default int64_t
@@ -378,11 +364,9 @@ public:
     virtual bool getAttr(const char* key, float& value) const = 0;
     virtual bool getAttr(const char* key, double& value) const = 0;
     virtual bool getAttr(const char* key, Vec2& value) const = 0;
-    virtual bool getAttr(const char* key, Vec2d& value) const = 0;
     virtual bool getAttr(const char* key, Ang3& value) const = 0;
     virtual bool getAttr(const char* key, Vec3& value) const = 0;
     virtual bool getAttr(const char* key, Vec4& value) const = 0;
-    virtual bool getAttr(const char* key, Vec3d& value) const = 0;
     virtual bool getAttr(const char* key, Quat& value) const = 0;
     virtual bool getAttr(const char* key, bool& value) const = 0;
     virtual bool getAttr(const char* key, XmlString& value) const = 0;
@@ -401,13 +385,6 @@ public:
     }
 #endif
 
-    // </interfuscator:shuffle>
-
-    // <interfuscator:shuffle>
-    // Summary:
-    //   Collect all allocated memory
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
-
     // Summary:
     //   Copies children to this node from a given node.
     //   Children are reference copied (shallow copy) and the children's parent is NOT set to this
@@ -700,7 +677,7 @@ public:
 
     XmlNodeRefIterator& operator=(const XmlNodeRefIterator& other) = default;
 
-    XmlNodeRefIterator& operator++() 
+    XmlNodeRefIterator& operator++()
     {
         ++m_index;
         Update();
@@ -714,7 +691,7 @@ public:
         return ret;
     }
 
-    IXmlNode* operator*() const 
+    IXmlNode* operator*() const
     {
         return m_currentChildNode;
     }
@@ -794,7 +771,6 @@ struct IXmlSerializer
     virtual ISerialize* GetWriter(XmlNodeRef& node) = 0;
     virtual ISerialize* GetReader(XmlNodeRef& node) = 0;
     // </interfuscator:shuffle>
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -802,7 +778,6 @@ struct IXmlSerializer
 //   XML Parser interface.
 struct IXmlParser
 {
-    // <interfuscator:shuffle>
     virtual ~IXmlParser(){}
     virtual void AddRef() = 0;
     virtual void Release() = 0;
@@ -814,9 +789,6 @@ struct IXmlParser
     // Summary:
     //   Parses xml from memory buffer.
     virtual XmlNodeRef ParseBuffer(const char* buffer, int nBufLen, bool bCleanPools, bool bSuppressWarnings = false) = 0;
-
-    virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
-    // </interfuscator:shuffle>
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -863,7 +835,6 @@ struct IXmlTableReader
     // to know absolute cell index (i.e. column).
     // Returns false if no cells left in the row.
     virtual bool ReadCell(int& columnIndex, const char*& pContent, size_t& contentSize) = 0;
-    virtual float GetCurrentRowHeight() = 0;
     // </interfuscator:shuffle>
 };
 
@@ -877,28 +848,17 @@ struct IXmlUtils
 
     // Summary:
     //   Loads xml file, returns 0 if load failed.
-    virtual XmlNodeRef LoadXmlFromFile(const char* sFilename, bool bReuseStrings = false, bool bEnablePatching = true) = 0;
+    virtual XmlNodeRef LoadXmlFromFile(const char* sFilename, bool bReuseStrings = false) = 0;
     // Summary:
     //   Loads xml from memory buffer, returns 0 if load failed.
     virtual XmlNodeRef LoadXmlFromBuffer(const char* buffer, size_t size, bool bReuseStrings = false, bool bSuppressWarnings = false) = 0;
 
-    // Summary:
-    //   Creates an MD5 hash of an XML file
-    virtual const char* HashXml(XmlNodeRef node) = 0;
-
-    // Summary:
-    //   Gets an object that can read a xml into a IReadXMLSink
-    //   and writes a xml from a IWriteXMLSource
-    virtual IReadWriteXMLSink* GetIReadWriteXMLSink() = 0;
-
     // Summary:
     //   Creates XML Writer for ISerialize interface.
     // See also:
     //   IXmlSerializer
     virtual IXmlSerializer* CreateXmlSerializer() = 0;
-    // </interfuscator:shuffle>
 
-    // <interfuscator:shuffle>
     // Summary:
     //   Creates XML Parser.
     // Notes:
@@ -908,40 +868,9 @@ struct IXmlUtils
     //   After use it must be released with call to Release method.
     virtual IXmlParser* CreateXmlParser() = 0;
 
-    // Summary:
-    //   Creates XML to file in the binary form.
-    virtual bool SaveBinaryXmlFile(const char* sFilename, XmlNodeRef root) = 0;
-    // Summary:
-    //   Reads XML data from file in the binary form.
-    virtual XmlNodeRef LoadBinaryXmlFile(const char* sFilename, bool bEnablePatching = true) = 0;
-
-    // Summary:
-    //   Enables or disables checking for binary xml files.
-    // Return Value:
-    //   The previous status.
-    virtual bool EnableBinaryXmlLoading(bool bEnable) = 0;
-
     // Summary:
     //   Creates XML Table reader.
     // Notes:
     //   After use it must be released with call to Release method.
     virtual IXmlTableReader* CreateXmlTableReader() = 0;
-
-    // Init xml stats nodes pool
-    virtual void InitStatsXmlNodePool(uint32 nPoolSize) = 0;
-
-    // Creates new xml node for statistics.
-    virtual XmlNodeRef CreateStatsXmlNode(const char* sNodeName) = 0;
-    // Set owner thread
-    virtual void SetStatsOwnerThread(threadID threadId) = 0;
-
-    // Free memory held on to by xml pool if empty
-    virtual void FlushStatsXmlNodePool() = 0;
-
-    // Sets the patch which is used to transform loaded XML files. the patch itself is encoded into XML
-    // Set to NULL to clear an existing transform and disable further patching
-    virtual void SetXMLPatcher(XmlNodeRef* pPatcher) = 0;
-    // </interfuscator:shuffle>
 };
-
-#endif // CRYINCLUDE_CRYCOMMON_IXML_H

Code/Legacy/CryCommon/Linux_Win32Wrapper.h

@@ -429,7 +429,6 @@ extern DWORD GetCurrentProcessId(void);
 
 //helper function
 extern void adaptFilenameToLinux(char* rAdjustedFilename);
-extern const int comparePathNames(const char* cpFirst, const char* cpSecond, unsigned int len);//returns 0 if identical
 extern void replaceDoublePathFilename(char* szFileName);//removes "\.\" to "\" and "/./" to "/"
 
 //////////////////////////////////////////////////////////////////////////

Code/Legacy/CryCommon/LocalizationManagerBus.h

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <CrySizer.h>
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/std/containers/vector.h>
 #include <AzCore/std/string/string.h>

Code/Legacy/CryCommon/LyShine/Bus/UiTransform2dBus.h

@@ -42,10 +42,10 @@ public: // types
 
         void UnitClamp()
         {
-            m_left = FClamp(m_left, 0.0f, 1.0f);
-            m_top = FClamp(m_top, 0.0f, 1.0f);
-            m_right = FClamp(m_right, 0.0f, 1.0f);
-            m_bottom = FClamp(m_bottom, 0.0f, 1.0f);
+            m_left = AZStd::clamp(m_left, 0.0f, 1.0f);
+            m_top = AZStd::clamp(m_top, 0.0f, 1.0f);
+            m_right = AZStd::clamp(m_right, 0.0f, 1.0f);
+            m_bottom = AZStd::clamp(m_bottom, 0.0f, 1.0f);
         }
 
         bool operator==(const Anchors& rhs) const

Code/Legacy/CryCommon/MTPseudoRandom.cpp

@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Marsenne Twister PRNG. See MT.h for more info.
-
-#include "MTPseudoRandom.h"
-// non-inline function definitions and static member definitions cannot
-// reside in header file because of the risk of multiple declarations
-
-void CMTRand_int32::gen_state()   // generate new m_nState vector
-{
-    for (int i = 0; i < (n - m); ++i)
-    {
-        m_nState[i] = m_nState[i + m] ^ twiddle(m_nState[i], m_nState[i + 1]);
-    }
-    for (int i = n - m; i < (n - 1); ++i)
-    {
-        m_nState[i] = m_nState[i + m - n] ^ twiddle(m_nState[i], m_nState[i + 1]);
-    }
-    m_nState[n - 1] = m_nState[m - 1] ^ twiddle(m_nState[n - 1], m_nState[0]);
-    p = 0; // reset position
-}
-
-void CMTRand_int32::seed(uint32 s)    // init by 32 bit seed
-{   //if (s == 0)
-    //m_nRandom = 1;
-    for (int i = 0; i < n; ++i)
-    {
-        m_nState[i] = 0x0UL;
-    }
-    m_nState[0] = s;
-    for (int i = 1; i < n; ++i)
-    {
-        m_nState[i] = 1812433253UL * (m_nState[i - 1] ^ (m_nState[i - 1] >> 30)) + i;
-        // see Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier
-        // in the previous versions, MSBs of the seed affect only MSBs of the array m_nState
-        // 2002/01/09 modified by Makoto Matsumoto
-    }
-    p = n; // force gen_state() to be called for next random number
-}
-
-void CMTRand_int32::seed(const uint32* array, int size)   // init by array
-{
-    seed(19650218UL);
-    int i = 1, j = 0;
-    for (int k = ((n > size) ? n : size); k; --k)
-    {
-        m_nState[i] = (m_nState[i] ^ ((m_nState[i - 1] ^ (m_nState[i - 1] >> 30)) * 1664525UL))
-            + array[j] + j; // non linear
-        ++j;
-        j %= size;
-        if ((++i) == n)
-        {
-            m_nState[0] = m_nState[n - 1];
-            i = 1;
-        }
-    }
-    for (int k = n - 1; k; --k)
-    {
-        m_nState[i] = (m_nState[i] ^ ((m_nState[i - 1] ^ (m_nState[i - 1] >> 30)) * 1566083941UL)) - i;
-        if ((++i) == n)
-        {
-            m_nState[0] = m_nState[n - 1];
-            i = 1;
-        }
-    }
-    m_nState[0] = 0x80000000UL; // MSB is 1; assuring non-zero initial array
-    p = n; // force gen_state() to be called for next random number
-}

Code/Legacy/CryCommon/MTPseudoRandom.h

@@ -1,166 +0,0 @@
-// mtrand.h
-// C++ include file for MT19937, with initialization improved 2002/1/26.
-// Coded by Takuji Nishimura and Makoto Matsumoto.
-// Ported to C++ by Jasper Bedaux 2003/1/1 (see http://www.bedaux.net/mtrand/).
-// The generators returning floating point numbers are based on
-// a version by Isaku Wada, 2002/01/09
-// Static shared data converted to per-instance, 2008-11-13 by JSP.
-//
-// Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// 1. Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-//    notice, this list of conditions and the following disclaimer in the
-//    documentation and/or other materials provided with the distribution.
-//
-// 3. The names of its contributors may not be used to endorse or promote
-//    products derived from this software without specific prior written
-//    permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Any feedback is very welcome.
-// http://www.math.keio.ac.jp/matumoto/emt.html
-// email: [email protected]
-//
-// Feedback about the C++ port should be sent to Jasper Bedaux,
-// see http://www.bedaux.net/mtrand/ for e-mail address and info.
-
-//-------------------------------------------------------------------------
-// History:
-// - 28:7:2005: File created and minor changes by Marco Corbetta
-//
-//*************************************************************************/
-// Modified from original
-
-#ifndef CRYINCLUDE_CRYCOMMON_MTPSEUDORANDOM_H
-#define CRYINCLUDE_CRYCOMMON_MTPSEUDORANDOM_H
-#pragma once
-
-#include <CryRandomInternal.h>
-
-//////////////////////////////////////////////////////////////////////////
-class CMTRand_int32 
-{ 
-    // Mersenne Twister random number generator
-
-public:
-    // default constructor
-    CMTRand_int32() { seed(5489UL); }
-    // constructor with 32 bit int as seed
-    CMTRand_int32(uint32 seed_value) { seed(seed_value); }
-    // constructor with array of 32 bit integers as seed
-    CMTRand_int32(const uint32* array, int size) { seed(array, size); }
-    // seeds with 32 bit integer
-    void seed(uint32 seed_value);
-    // seeds with array
-    void seed(const uint32*, int size);
-    // overloaded operator() to make this a generator (functor)
-    //uint32 operator()() { return rand_int32(); }
-
-    ~CMTRand_int32() {}
-
-    // Functions with PascalCase names were added for
-    // interchangeability with CRndGen (see LCGRandom.h).
-
-    void Seed(uint32 seed_value)
-    {
-        seed(seed_value);
-    }
-
-    uint32 GenerateUint32()
-    {
-        return rand_int32();
-    }
-
-    uint64 GenerateUint64()
-    {
-        const uint32 a = GenerateUint32();
-        const uint32 b = GenerateUint32();
-        return ((uint64)b << 32) | (uint64)a;
-    }
-
-    float GenerateFloat()
-    {
-        return (float)GenerateUint32() * (1.0f / 4294967295.0f);
-    }
-
-    // Ranged function returns random value within the *inclusive* range
-    // between minValue and maxValue.
-    // Any orderings work correctly: minValue <= maxValue and 
-    // minValue >= minValue.
-    template <class T>
-    T GetRandom(const T minValue, const T maxValue)
-    {
-        return CryRandom_Internal::BoundedRandom<CMTRand_int32, T>::Get(*this, minValue, maxValue);
-    }
-
-    // Vector (Vec2, Vec3, Vec4) ranged function returns vector    with 
-    // every component within the *inclusive* ranges between minValue.component
-    // and maxValue.component.
-    // All orderings work correctly: minValue.component <= maxValue.component and
-    // minValue.component >= maxValue.component.
-    template <class T>
-    T GetRandomComponentwise(const T& minValue, const T& maxValue)
-    {
-        return CryRandom_Internal::BoundedRandomComponentwise<CMTRand_int32, T>::Get(*this, minValue, maxValue);
-    }
-
-    // The function returns a random unit vector (Vec2, Vec3, Vec4).
-    template <class T>
-    T GetRandomUnitVector()
-    {
-        return CryRandom_Internal::GetRandomUnitVector<CMTRand_int32, T>(*this);
-    }
-
-protected: // used by derived classes, otherwise not accessible; use the ()-operator
-    // generates 32 bit random int
-    uint32 rand_int32() 
-    { 
-        if (p >= n) gen_state(); // new m_nState vector needed
-        // gen_state() is split off to be non-inline, because it is only called once
-        // in every 624 calls and otherwise irand() would become too big to get inlined
-        uint32 x = m_nState[p++];
-        x ^= (x >> 11);
-        x ^= (x << 7) & 0x9D2C5680UL;
-        x ^= (x << 15) & 0xEFC60000UL;
-        return x ^ (x >> 18);
-    }
-
-private:
-    static const int n = 624, m = 397; // compile time constants
-
-    // the variables below are static (no duplicates can exist)
-    uint32 m_nState[n+1]; // m_nState vector array
-    int p; // position in m_nState array
-    // private functions used to generate the pseudo random numbers
-    uint32 twiddle(uint32 u, uint32 v) 
-    {
-        return (((u & 0x80000000UL) | (v & 0x7FFFFFFFUL)) >> 1)
-            ^ ((v & 1UL) ? 0x9908B0DFUL : 0x0UL);
-    }
-    void gen_state(); // generate new m_nState
-    // make copy constructor and assignment operator unavailable, they don't make sense
-    CMTRand_int32(const CMTRand_int32&); // copy constructor not defined
-    void operator=(const CMTRand_int32&); // assignment operator not defined
-};
-
-
-#endif // CRYINCLUDE_CRYCOMMON_MTPSEUDORANDOM_H

Code/Legacy/CryCommon/MathConversion.h

@@ -153,35 +153,6 @@ inline AZ::Matrix3x4 LYTransformToAZMatrix3x4(const Matrix34& source)
     return AZ::Matrix3x4::CreateFromRowMajorFloat12(source.GetData());
 }
 
-inline AZ::Transform LYQuatTToAZTransform(const QuatT& source)
-{
-    return AZ::Transform::CreateFromQuaternionAndTranslation(
-        LYQuaternionToAZQuaternion(source.q),
-        LYVec3ToAZVec3(source.t));
-}
-
-inline QuatT AZTransformToLYQuatT(const AZ::Transform& source)
-{
-    return QuatT(
-        AZQuaternionToLYQuaternion(source.GetRotation()),
-        AZVec3ToLYVec3(source.GetTranslation()));
-}
-
-inline QuatT AZMatrix3x4ToLYQuatT(const AZ::Matrix3x4& source)
-{
-    AZ::Matrix3x4 sourceNoScale(source);
-    sourceNoScale.ExtractScale();
-
-    return QuatT(
-        AZQuaternionToLYQuaternion(AZ::Quaternion::CreateFromMatrix3x4(sourceNoScale)),
-        AZVec3ToLYVec3(source.GetTranslation()));
-}
-
-inline DualQuat AZMatrix3x4ToLYDualQuat(const AZ::Matrix3x4& matrix3x4)
-{
-    return DualQuat(AZMatrix3x4ToLYMatrix3x4(matrix3x4));
-}
-
 inline AABB AZAabbToLyAABB(const AZ::Aabb& source)
 {
     return AABB(AZVec3ToLYVec3(source.GetMin()), AZVec3ToLYVec3(source.GetMax()));

Code/Legacy/CryCommon/MetaUtils.h

@@ -1,135 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_METAUTILS_H
-#define CRYINCLUDE_CRYCOMMON_METAUTILS_H
-#pragma once
-
-
-
-namespace metautils
-{
-    // select
-
-    template<bool Condition, typename Ty1, typename Ty2>
-    struct select;
-
-    template<typename Ty1, typename Ty2>
-    struct select<true, Ty1, Ty2>
-    {
-        typedef Ty1 type;
-    };
-
-    template<typename Ty1, typename Ty2>
-    struct select<false, Ty1, Ty2>
-    {
-        typedef Ty2 type;
-    };
-
-    // is_same
-    // Identifies whether types Ty1 and Ty2 are the same including const & volatile.
-
-    template<typename Ty1, typename Ty2>
-    struct is_same;
-
-    template<typename Ty1>
-    struct is_same<Ty1, Ty1>
-    {
-        enum
-        {
-            value = true,
-        };
-    };
-
-    template<typename Ty1, typename Ty2>
-    struct is_same
-    {
-        enum
-        {
-            value = false,
-        };
-    };
-
-    // remove_const
-    // Removes top level const qualifier.
-
-    template<class Ty>
-    struct remove_const
-    {
-        typedef Ty type;
-    };
-
-    template<class Ty>
-    struct remove_const<const Ty>
-    {
-        typedef Ty type;
-    };
-
-    template<class Ty>
-    struct remove_const<const Ty[]>
-    {
-        typedef Ty type[];
-    };
-
-    template<class Ty, unsigned int N>
-    struct remove_const<const Ty[N]>
-    {
-        typedef Ty type[N];
-    };
-
-    // is_const
-    // Determines whether type Ty is const qualified.
-
-    template <typename Ty>
-    struct is_const
-    {
-        enum
-        {
-            value = false
-        };
-    };
-
-    template <typename Ty>
-    struct is_const<const Ty>
-    {
-        enum
-        {
-            value = true
-        };
-    };
-
-    template<class Ty, unsigned int N>
-    struct is_const<Ty[N]>
-    {
-        enum
-        {
-            value = false
-        };
-    };
-
-    template<class Ty, unsigned int N>
-    struct is_const<const Ty[N]>
-    {
-        enum
-        {
-            value = true
-        };
-    };
-
-    template<class Ty>
-    struct is_const<Ty&>
-    {
-        enum
-        {
-            value = false
-        };
-    };
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_METAUTILS_H

Code/Legacy/CryCommon/Mocks/ICVarMock.h

@@ -11,7 +11,7 @@
 #include <IConsole.h>
 #include <AzTest/AzTest.h>
 
-#include <SFunctor.h>
+#include <AzCore/std/function/function_template.h>
 
 class CVarMock
     : public ICVar
@@ -35,9 +35,8 @@ public:
     MOCK_METHOD0(GetHelp, const char*());
     MOCK_CONST_METHOD0(IsConstCVar, bool());
     MOCK_METHOD1(SetOnChangeCallback, void(ConsoleVarFunc));
-    MOCK_METHOD1(AddOnChangeFunctor, uint64(const SFunctor& pChangeFunctor));
+    MOCK_METHOD1(AddOnChangeFunctor, uint64(const AZStd::function<void()>& pChangeFunctor));
     MOCK_CONST_METHOD0(GetOnChangeCallback, ConsoleVarFunc());
-    MOCK_CONST_METHOD1(GetMemoryUsage, void(class ICrySizer* pSizer));
     MOCK_CONST_METHOD0(GetRealIVal, int());
     MOCK_METHOD2(SetLimits, void(float, float));
     MOCK_METHOD2(GetLimits, void(float&, float&));

Code/Legacy/CryCommon/Mocks/IConsoleMock.h

@@ -21,12 +21,10 @@ public:
     MOCK_METHOD1(Init, void(ISystem * pSystem));
     MOCK_METHOD5(RegisterString, ICVar * (const char* sName, const char* sValue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc));
     MOCK_METHOD5(RegisterInt, ICVar * (const char* sName, int iValue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc));
-    MOCK_METHOD5(RegisterInt64, ICVar * (const char* sName, int64 iValue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc));
     MOCK_METHOD5(RegisterFloat, ICVar * (const char* sName, float fValue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc));
     MOCK_METHOD7(Register, ICVar * (const char* name, float* src, float defaultvalue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc, bool allowModify));
     MOCK_METHOD7(Register, ICVar * (const char* name, int* src, int defaultvalue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc, bool allowModify));
     MOCK_METHOD7(Register, ICVar * (const char* name, const char** src, const char* defaultvalue, int nFlags, const char* help, ConsoleVarFunc pChangeFunc, bool allowModify));
-    MOCK_METHOD1(Register, ICVar * (ICVar * pVar));
     MOCK_METHOD2(UnregisterVariable, void(const char* sVarName, bool bDelete ));
     MOCK_METHOD1(SetScrollMax, void(int value));
     MOCK_METHOD1(AddOutputPrintSink, void(IOutputPrintSink * inpSink));
@@ -63,7 +61,6 @@ public:
     MOCK_METHOD2(RegisterAutoComplete, void (const char* sVarOrCommand, IConsoleArgumentAutoComplete * pArgAutoComplete));
     MOCK_METHOD1(UnRegisterAutoComplete, void (const char* sVarOrCommand));
     MOCK_METHOD0(ResetAutoCompletion, void ());
-    MOCK_CONST_METHOD1(GetMemoryUsage, void (ICrySizer * pSizer));
     MOCK_METHOD1(ResetProgressBar, void (int nProgressRange));
     MOCK_METHOD0(TickProgressBar, void ());
     MOCK_METHOD1(SetInputLine, void (const char* szLine));

Code/Legacy/CryCommon/Mocks/ILogMock.h

@@ -48,8 +48,6 @@ public:
         void());
     MOCK_METHOD0(GetModuleFilter,
         const char*());
-    MOCK_CONST_METHOD1(GetMemoryUsage,
-        void(ICrySizer * pSizer));
     MOCK_METHOD1(Indent,
         void(class CLogIndenter * indenter));
     MOCK_METHOD1(Unindent,

Code/Legacy/CryCommon/MultiThread_Containers.h

@@ -6,13 +6,9 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_MULTITHREAD_CONTAINERS_H
-#define CRYINCLUDE_CRYCOMMON_MULTITHREAD_CONTAINERS_H
 #pragma once
 
 #include "StlUtils.h"
-#include "BitFiddling.h"
 
 #include <queue>
 #include <set>
@@ -43,8 +39,6 @@ namespace CryMT
         const T& back() const { AutoLock lock(m_cs);    return v.back(); }
         void    push(const T& x)    { AutoLock lock(m_cs); return v.push_back(x); };
         void reserve(const size_t n) { AutoLock lock(m_cs); v.reserve(n); };
-        // classic pop function of queue should not be used for thread safety, use try_pop instead
-        //void  pop()                           { AutoLock lock(m_cs); return v.erase(v.begin()); };
 
         AZStd::recursive_mutex& get_lock() const { return m_cs; }
 
@@ -69,27 +63,6 @@ namespace CryMT
             return false;
         };
 
-        //////////////////////////////////////////////////////////////////////////
-        bool try_remove(const T& value)
-        {
-            AutoLock lock(m_cs);
-            if (!v.empty())
-            {
-                typename container_type::iterator it = std::find(v.begin(), v.end(), value);
-                if (it != v.end())
-                {
-                    v.erase(it);
-                    return true;
-                }
-            }
-            return false;
-        };
-
-        template<typename Sizer>
-        void GetMemoryUsage(Sizer* pSizer) const
-        {
-            pSizer->AddObject(v);
-        }
     private:
         container_type v;
         mutable AZStd::recursive_mutex m_cs;
@@ -104,6 +77,3 @@ namespace stl
         v.free_memory();
     }
 }
-
-
-#endif // CRYINCLUDE_CRYCOMMON_MULTITHREAD_CONTAINERS_H

Code/Legacy/CryCommon/Random.h

@@ -6,9 +6,6 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_RANDOM_H
-#define CRYINCLUDE_CRYCOMMON_RANDOM_H
 #pragma once
 
 #include "BaseTypes.h"
@@ -21,22 +18,11 @@ namespace CryRandom_Internal
 }
 
 
-// Seed the global random number generator.
-inline void cry_random_seed(const uint32 nSeed)
-{
-    CryRandom_Internal::g_random_generator.Seed(nSeed);
-}
-
 inline uint32 cry_random_uint32()
 {
     return CryRandom_Internal::g_random_generator.GenerateUint32();
 }
 
-inline float cry_frand()
-{
-    return CryRandom_Internal::g_random_generator.GenerateFloat();
-}
-
 // Ranged function returns random value within the *inclusive* range
 // between minValue and maxValue.
 // Any orderings work correctly: minValue <= maxValue and
@@ -46,24 +32,3 @@ inline T cry_random(const T minValue, const T maxValue)
 {
     return CryRandom_Internal::g_random_generator.GetRandom(minValue, maxValue);
 }
-
-// Vector (Vec2, Vec3, Vec4) ranged function returns vector with
-// every component within the *inclusive* ranges between minValue.component
-// and maxValue.component.
-// All orderings work correctly: minValue.component <= maxValue.component and
-// minValue.component >= maxValue.component.
-template <class T>
-inline T cry_random_componentwise(const T& minValue, const T& maxValue)
-{
-    return CryRandom_Internal::g_random_generator.GetRandomComponentwise(minValue, maxValue);
-}
-
-// The function returns a random unit vector (Vec2, Vec3, Vec4).
-template <class T>
-inline T cry_random_unit_vector()
-{
-    return CryRandom_Internal::g_random_generator.GetRandomUnitVector<T>();
-}
-
-// eof
-#endif // CRYINCLUDE_CRYCOMMON_RANDOM_H

Code/Legacy/CryCommon/RenderBus.h

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-
-namespace AZ
-{
-    /**
-    * This bus serves as a way for non-rendering systems to react to events
-    * that occur inside the renderer. For now these events will probably be implemented by
-    * things like CSystem and CryAction. In the future the idea is that these can be implemented
-    * by a user's GameComponent.
-    */
-    class RenderNotifications
-        : public AZ::EBusTraits
-    {
-    public:
-        virtual ~RenderNotifications() = default;
-
-        //////////////////////////////////////////////////////////////////////////
-        // EBusTraits overrides
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-        //////////////////////////////////////////////////////////////////////////
-
-        /**
-        * This event gets posted at the beginning of CD3D9Renderer's FreeResources method, before the resources have been freed.
-        */
-        virtual void OnRendererFreeResources([[maybe_unused]] int flags) {};
-    };
-
-    using RenderNotificationsBus = AZ::EBus<RenderNotifications>;
-
-    /**
-    * This bus is used for renderer notifications that occur directly from the render thread
-    * while scene rendering is occurring.  (In contrast, the RenderNotificationsBus above runs on the
-    * main thread while the renderer is preparing the scene.)
-    */
-    class RenderThreadEvents
-        : public AZ::EBusTraits
-    {
-    public:
-        virtual ~RenderThreadEvents() = default;
-
-        //////////////////////////////////////////////////////////////////////////
-        // EBusTraits overrides
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-        //////////////////////////////////////////////////////////////////////////
-
-        /*
-        * This hook enables per-frame render work at the beginning of the frame.
-        *
-        * This event is triggered when RT_RenderScene is called at the beginning of a frame.
-        * The event will only be triggered on the render thread, if multithreaded rendering
-        * is enabled.  And, it will only be triggered on a non-recursive scene render.
-        */
-        virtual void OnRenderThreadRenderSceneBegin() {}
-    };
-
-    using RenderThreadEventsBus = AZ::EBus<RenderThreadEvents>;
-
-    /**
-    * This bus is used for firing screenshot request to any rendering system.
-    * The rendering system should implement its own screenshot function.
-    */
-    class RenderScreenshotRequests
-        : public AZ::EBusTraits
-    {
-    public:
-        static const EBusHandlerPolicy HandlerPolicy = EBusHandlerPolicy::Single; ///< EBusTraits overrides
-        static const EBusAddressPolicy AddressPolicy = EBusAddressPolicy::Single; ///< EBusTraits overrides
-
-        /** Take a screenshot and save it to a file.
-        @param filepath the path where a the screenshot is saved.
-        */
-        virtual void WriteScreenshotToFile(const char* filepath) = 0;
-
-        /** Take a screenshot and preserve it within a buffer
-        */
-        virtual void WriteScreenshotToBuffer() = 0;
-
-        /** Fill a provided buffer with the render buffer
-        @param imageBuffer The provided buffer to be filled
-        */
-        virtual bool CopyScreenshotToBuffer(unsigned char* imageBuffer, unsigned int width, unsigned int height) = 0;
-
-    };
-
-    using RenderScreenshotRequestBus = AZ::EBus<RenderScreenshotRequests>;
-
-    class RenderScreenshotNotifications
-        : public AZ::EBusTraits
-    {
-    public:
-        virtual ~RenderScreenshotNotifications() = default;
-
-        static const EBusAddressPolicy AddressPolicy = EBusAddressPolicy::Single; ///< EBusTraits overrides
-
-        /** Notify waiting components that the requested screenshot is ready
-        */
-        virtual void OnScreenshotReady() = 0;
-    };
-
-    using RenderScreenshotNotificationBus = AZ::EBus<RenderScreenshotNotifications>;
-}

Code/Legacy/CryCommon/SFunctor.h

@@ -1,112 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : User header for multi DLL functors.
-
-
-#ifndef CRYINCLUDE_CRYCOMMON_SFUNCTOR_H
-#define CRYINCLUDE_CRYCOMMON_SFUNCTOR_H
-#pragma once
-
-
-#include "FunctorBaseFunction.h"
-#include "FunctorBaseMember.h"
-
-// Needed for CryFont to compile.
-// Maybe for others too.
-#include "smartptr.h"
-
-
-struct SFunctor
-{
-public:
-    // Calls the functor method.
-    // returns true, if a functor is registered, false otherwise.
-    bool Call()
-    {
-        if (!m_pFunctor)
-        {
-            return false;
-        }
-
-        m_pFunctor->Call();
-
-        return true;
-    }
-
-    // Sets a new functor, common function, void return type, no arguments.
-    // Parameters: the function pointer.
-    template<typename tCallback>
-    void Set(tCallback pCallback)
-    {
-        typedef TFunctor<tCallback> TType;
-        m_pFunctor = new TType(pCallback);
-    }
-
-    // Sets a new functor, common function, void return type, 1 argument.
-    // Parameters: the function pointer, the argument to be passed to the function.
-    template<typename tCallback, typename tArgument1>
-    void Set(tCallback pCallback, const tArgument1& Argument1)
-    {
-        typedef TFunctor<tCallback> TType;
-        m_pFunctor = new TType(pCallback, Argument1);
-    }
-
-    // Sets a new functor, common function, void return type, 2 arguments.
-    // Parameters: the function pointer, the 2 arguments to be passed to the function.
-    template<typename tCallback, typename tArgument1, typename tArgument2>
-    void Set(tCallback pCallback, const tArgument1& Argument1, const tArgument2& Argument2)
-    {
-        typedef TFunctor<tCallback> TType;
-        m_pFunctor = new TType(pCallback, Argument1, Argument2);
-    }
-
-    // Sets a new functor, common function, void return type, no arguments.
-    // Parameters: the function pointer, the 2 arguments to be passed to the function.
-    template<typename tCallee>
-    void Set(tCallee* pCallee, void (tCallee::* pCallback)())
-    {
-        typedef TFunctor<void (tCallee::*)()> TType;
-        m_pFunctor = new TType(pCallee, pCallback);
-    }
-
-    // Sets a new functor, common function, void return type, 1 argument.
-    // Parameters: the function pointer, the 2 arguments to be passed to the function, the argument.
-    template<typename tCallee, typename tArgument1>
-    void Set(tCallee* pCallee, void (tCallee::* pCallback)(tArgument1), const tArgument1& Argument1)
-    {
-        typedef TFunctor<void (tCallee::*)(tArgument1)> TType;
-        m_pFunctor = new TType(pCallee, pCallback, Argument1);
-    }
-
-    // Sets a new functor, common function, void return type, 2 arguments.
-    // Parameters: the function pointer, the 2 arguments to be passed to the function, the 2 arguments.
-    template<typename tCallee, typename tArgument1, typename tArgument2>
-    void Set(tCallee* pCallee, void (tCallee::* pCallback)(tArgument1, tArgument2), const tArgument1& Argument1, const tArgument2& Argument2)
-    {
-        typedef TFunctor<void (tCallee::*)(tArgument1, tArgument2)> TType;
-        m_pFunctor = new TType(pCallee, pCallback, Argument1, Argument2);
-    }
-
-    // Used to compare equality between 2 IFunctors.
-    bool operator==(const SFunctor& rOther)
-    {
-        return m_pFunctor == rOther.m_pFunctor;
-    }
-
-    // Used order to IFunctors (needed for some containers, like map).
-    bool operator<(const SFunctor& rOther)
-    {
-        return m_pFunctor < rOther.m_pFunctor;
-    }
-protected:
-    _smart_ptr<IFunctorBase>    m_pFunctor;
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_SFUNCTOR_H

Code/Legacy/CryCommon/SerializationTypes.h

@@ -10,7 +10,6 @@
 
 SERIALIZATION_TYPE(bool)
 SERIALIZATION_TYPE(float)
-SERIALIZATION_TYPE(double)
 SERIALIZATION_TYPE(Vec2)
 SERIALIZATION_TYPE(Vec3)
 SERIALIZATION_TYPE(Quat)
@@ -24,5 +23,3 @@ SERIALIZATION_TYPE(uint16)
 SERIALIZATION_TYPE(uint32)
 SERIALIZATION_TYPE(uint64)
 SERIALIZATION_TYPE(CTimeValue)
-SERIALIZATION_TYPE(SNetObjectID)
-SERIALIZATION_TYPE(XmlNodeRef) // not for network - only for save games

Code/Legacy/CryCommon/SerializeFwd.h

@@ -6,18 +6,10 @@
  *
  */
 
-
 // Description : forward declaration of TSerialize
-
-#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZEFWD_H
-#define CRYINCLUDE_CRYCOMMON_SERIALIZEFWD_H
 #pragma once
 
-
-
 template <class T>
 class CSerializeWrapper;
 struct ISerialize;
 typedef CSerializeWrapper<ISerialize> TSerialize;
-
-#endif // CRYINCLUDE_CRYCOMMON_SERIALIZEFWD_H

Code/Legacy/CryCommon/SimpleSerialize.h

@@ -6,78 +6,29 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_SIMPLESERIALIZE_H
-#define CRYINCLUDE_CRYCOMMON_SIMPLESERIALIZE_H
 #pragma once
 
-
-#include <ISerialize.h> // <> required for Interfuscator
 #include "TimeValue.h"
+#include <ISerialize.h> // <> required for Interfuscator
 
-template <bool READING>
-class CSimpleSerializeImpl_Reading;
-
-template <>
-class CSimpleSerializeImpl_Reading<true>
+template<bool READING, ESerializationTarget TARGET>
+class CSimpleSerializeImpl
 {
 public:
-    CSimpleSerializeImpl_Reading()
-        : m_bCommit(true) {}
-    ILINE bool IsReading() const
-    {
-        return true;
-    }
-    ILINE bool ShouldCommitValues() const
-    {
-        return m_bCommit;
-    }
-    ILINE void Update(ISerializeUpdateFunction* pFunc)
+    CSimpleSerializeImpl()
+        : m_failed(false)
     {
-        if (m_bCommit)
-        {
-            pFunc->Execute();
-        }
     }
-protected:
-    bool m_bCommit;
-};
-
-template <>
-class CSimpleSerializeImpl_Reading<false>
-{
-public:
     ILINE bool IsReading() const
     {
-        return false;
-    }
-    ILINE bool ShouldCommitValues() const
-    {
-        return true;
-    }
-    ILINE void Update(ISerializeUpdateFunction*)
-    {
+        return READING;
     }
-};
-
-template <bool READING, ESerializationTarget TARGET>
-class CSimpleSerializeImpl
-    : public CSimpleSerializeImpl_Reading<READING>
-{
-public:
-    CSimpleSerializeImpl()
-        : m_failed(false) {}
     ILINE void BeginGroup(const char* szName)
     {
     }
     ILINE void EndGroup()
     {
     }
-    ILINE ESerializationTarget GetSerializationTarget() const
-    {
-        return TARGET;
-    }
-    ILINE void FlagPartialRead() {}
 
     ILINE bool Ok() const
     {
@@ -94,9 +45,8 @@ private:
     bool m_failed;
 };
 
-template <class Impl>
-class CSimpleSerialize
-    : public ISerialize
+template<class Impl>
+class CSimpleSerialize : public ISerialize
 {
 public:
     ILINE CSimpleSerialize(Impl& impl)
@@ -104,11 +54,6 @@ public:
     {
     }
 
-    void Update(ISerializeUpdateFunction* pFunc)
-    {
-        m_impl.Update(pFunc);
-    }
-
     void BeginGroup(const char* szName)
     {
         m_impl.BeginGroup(szName);
@@ -129,47 +74,25 @@ public:
         return m_impl.IsReading();
     }
 
-    bool ShouldCommitValues() const
-    {
-        return m_impl.ShouldCommitValues();
-    }
-
-    ESerializationTarget GetSerializationTarget() const
-    {
-        return m_impl.GetSerializationTarget();
-    }
-
-    void WriteStringValue(const char* name, SSerializeString& value, uint32 policy)
+    void WriteStringValue(const char* name, SSerializeString& value)
     {
-        m_impl.Value(name, value, policy);
+        m_impl.Value(name, value);
     }
-    void ReadStringValue(const char* name, SSerializeString& curValue, uint32 policy)
+    void ReadStringValue(const char* name, SSerializeString& curValue)
     {
-        m_impl.Value(name, curValue, policy);
+        m_impl.Value(name, curValue);
     }
 
-    bool Ok() const
-    {
-        return m_impl.Ok();
+#define SERIALIZATION_TYPE(T)                                                                                                              \
+    void Value(const char* name, T& x) override                                                                              \
+    {                                                                                                                                      \
+        m_impl.Value(name, x);                                                                                                     \
     }
-
-    void FlagPartialRead()
-    {
-        m_impl.FlagPartialRead();
-    }
-
-#define SERIALIZATION_TYPE(T) \
-    virtual void Value(const char* name, T & x, uint32 policy) { m_impl.Value(name, x, policy); }
 #include "SerializationTypes.h"
 #undef SERIALIZATION_TYPE
 
-#define SERIALIZATION_TYPE(T) \
-    virtual void ValueWithDefault([[maybe_unused]] const char* name, [[maybe_unused]] T & x, [[maybe_unused]] const T&defaultValue) { assert(0); }
-#include "SerializationTypes.h"
-    SERIALIZATION_TYPE(SSerializeString)
-#undef SERIALIZATION_TYPE
-
-    Impl * GetInnerImpl() {
+    Impl* GetInnerImpl()
+    {
         return &m_impl;
     }
 
@@ -181,26 +104,5 @@ protected:
 // Support serialization with default values,
 // Require Implementation serialization stub to have Value() method returning boolean.
 //////////////////////////////////////////////////////////////////////////
-template <class Impl>
-class CSimpleSerializeWithDefaults
-    : public CSimpleSerialize<Impl>
-{
-public:
-    ILINE CSimpleSerializeWithDefaults(Impl& impl)
-        : CSimpleSerialize<Impl>(impl) {}
-
-#define SERIALIZATION_TYPE(T)                                                      \
-    virtual void ValueWithDefault(const char* name, T & x, const T&defaultValue) { \
-        if (CSimpleSerialize<Impl>::m_impl.IsReading()) {                          \
-            if (!CSimpleSerialize<Impl>::m_impl.Value(name, x, 0)) {               \
-                x = defaultValue; }                                                \
-        }                                                                          \
-        else if (x != defaultValue) {                                              \
-            CSimpleSerialize<Impl>::m_impl.Value(name, x, 0); }                    \
-    }
-#include "SerializationTypes.h"
-    SERIALIZATION_TYPE(SSerializeString)
-#undef SERIALIZATION_TYPE
-};
-
-#endif // CRYINCLUDE_CRYCOMMON_SIMPLESERIALIZE_H
+template<class Impl>
+using CSimpleSerializeWithDefaults = CSimpleSerialize<Impl>;

Code/Legacy/CryCommon/StatObjBus.h

@@ -5,47 +5,15 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
-#ifndef CRYINCLUDE_CRYCOMMON_STATOBJBUS_H
-#define CRYINCLUDE_CRYCOMMON_STATOBJBUS_H
+#pragma once
 
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/std/containers/unordered_set.h>
 
-struct IStatObj;
-
-//////////////////////////////////////////////////////////////////////////
-//
-// Ebus support for handling unique IDs between IStatInstGroup instances.
-//
-//////////////////////////////////////////////////////////////////////////
-using StatInstGroupId = int;
-
-class StatInstGroupEvents
-    : public AZ::EBusTraits
-{
-public:
-    const static StatInstGroupId s_InvalidStatInstGroupId = -1;
-
-    virtual ~StatInstGroupEvents() = default;
-
-    // AZ::EBusTraits
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-    using MutexType = AZStd::recursive_mutex;
-
-    virtual StatInstGroupId GenerateStatInstGroupId() = 0;
-    virtual void ReleaseStatInstGroupId(StatInstGroupId statInstGroupId) = 0;
-    virtual void ReleaseStatInstGroupIdSet(const AZStd::unordered_set<StatInstGroupId>& statInstGroupIdSet) = 0;
-    virtual void ReserveStatInstGroupIdRange(StatInstGroupId from, StatInstGroupId to) = 0;
-};
-
-using StatInstGroupEventBus = AZ::EBus<StatInstGroupEvents>;
-
 //////////////////////////////////////////////////////////////////////////
 //
 // EBUS support for triggering necessary updates when IStatObj instances
-// caches should be updated when 3D Engine events happen during level loads, 
+// caches should be updated when 3D Engine events happen during level loads,
 // shutting down the application, and so forth
 //
 //////////////////////////////////////////////////////////////////////////
@@ -66,6 +34,3 @@ public:
 };
 
 using InstanceStatObjEventBus = AZ::EBus<InstanceStatObjEvents>;
-
-#endif // CRYINCLUDE_CRYCOMMON_STATOBJBUS_H
-#pragma once

Code/Legacy/CryCommon/Synchronization.h

@@ -6,9 +6,6 @@
  *
  */
 
-
-#ifndef CRYINCLUDE_CRYCOMMON_SYNCHRONIZATION_H
-#define CRYINCLUDE_CRYCOMMON_SYNCHRONIZATION_H
 #pragma once
 
 
@@ -25,46 +22,4 @@
 
 namespace stl
 {
-    template<class Sync>
-    struct AutoLock
-    {
-        ILINE AutoLock(Sync& sync)
-            : _sync(sync)
-        {
-            sync.Lock();
-        }
-        ILINE ~AutoLock()
-        {
-            _sync.Unlock();
-        }
-
-    private:
-        Sync& _sync;
-    };
-
-
-    struct PSyncNone
-    {
-        void Lock() {}
-        void Unlock() {}
-    };
-
-    struct PSyncMultiThread
-    {
-        PSyncMultiThread() {}
-
-        void Lock()
-        {
-            m_lock.lock();
-        }
-        void Unlock()
-        {
-            m_lock.unlock();
-        }
-
-    private:
-        AZStd::spin_mutex m_lock;
-    };
 };
-
-#endif // CRYINCLUDE_CRYCOMMON_SYNCHRONIZATION_H

Code/Legacy/CryCommon/TimeValue.h

@@ -21,8 +21,6 @@ public:
     static const int64      TIMEVALUE_PRECISION = 100000;         // one second
 
 public:
-    void GetMemoryUsage(class ICrySizer*) const { /*nothing*/}
-
     // Default constructor.
     ILINE CTimeValue()
     {
@@ -164,8 +162,6 @@ public:
     ILINE bool operator==(const CTimeValue& inRhs) const { return m_lValue == inRhs.m_lValue; };
     ILINE bool operator!=(const CTimeValue& inRhs) const { return m_lValue != inRhs.m_lValue; };
 
-    void GetMemoryStatistics(class ICrySizer*) const { /*nothing*/}
-
 private: // ----------------------------------------------------------
 
     int64                                   m_lValue;                                               // absolute or relative value in 1/TIMEVALUE_PRECISION, might be negative

Code/Legacy/CryCommon/VertexFormats.h

@@ -6,12 +6,9 @@
  *
  */
 
-
 #pragma once
 
 #include <CryCommon/Cry_Math.h>
-// Stream Configuration options
-#define ENABLE_NORMALSTREAM_SUPPORT 1
 
 enum EVertexFormat : uint8
 {
@@ -32,9 +29,6 @@ enum EVertexFormat : uint8
     eVF_Max,
 };
 
-
-typedef Vec4_tpl<int16> Vec4sf;     // Used for tangents only.
-
 struct UCol
 {
     union
@@ -90,7 +84,7 @@ struct Vec3f16
         w = CryConvertFloatToHalf(1.0f);
         return *this;
     }
-    _inline Vec3f16& operator = (const Vec4A& sl)
+    _inline Vec3f16& operator = (const Vec4& sl)
     {
         x = CryConvertFloatToHalf(sl.x);
         y = CryConvertFloatToHalf(sl.y);
@@ -108,44 +102,6 @@ struct Vec3f16
     }
 };
 
-struct Vec2f16
-    : public CryHalf2
-{
-    _inline Vec2f16()
-    {
-    }
-    _inline Vec2f16(f32 _x, f32 _y)
-    {
-        x = CryConvertFloatToHalf(_x);
-        y = CryConvertFloatToHalf(_y);
-    }
-    Vec2f16& operator = (const Vec2f16& sl)
-    {
-        x = sl.x;
-        y = sl.y;
-        return *this;
-    }
-    Vec2f16& operator = (const Vec2& sl)
-    {
-        x = CryConvertFloatToHalf(sl.x);
-        y = CryConvertFloatToHalf(sl.y);
-        return *this;
-    }
-    float operator[](int i) const
-    {
-        assert(i <= 1);
-        return CryConvertHalfToFloat(((CryHalf*)this)[i]);
-    }
-    _inline Vec2 ToVec2() const
-    {
-        Vec2 v;
-        v.x = CryConvertHalfToFloat(x);
-        v.y = CryConvertHalfToFloat(y);
-        return v;
-    }
-};
-
-
 struct SVF_P3F_C4B
 {
     Vec3 xyz;
@@ -170,381 +126,7 @@ struct SVF_P2F_C4B_T2F_F4B
     uint8 pad;
 };
 
-struct SVF_P3S_C4B_T2S
-{
-    Vec3f16 xyz;
-    UCol color;
-    Vec2f16 st;
-};
-
-struct SVF_W4B_I4S
-{
-    UCol weights;
-    uint16 indices[4];
-};
-
 struct SVF_P3F
 {
     Vec3 xyz;
 };
-
-//=============================================================
-// Signed norm value packing [-1,+1]
-
-namespace PackingSNorm
-{
-    ILINE int16 tPackF2B(const float f)
-    {
-        return (int16)(f * 32767.0f);
-    }
-
-    ILINE int16 tPackS2B(const int16 s)
-    {
-        return (int16)(s * 32767);
-    }
-
-    ILINE float tPackB2F(const int16 i)
-    {
-        return (float)((float)i / 32767.0f);
-    }
-
-    ILINE int16 tPackB2S(const int16 s)
-    {
-        // OPT: "(s >> 15) + !(s >> 15)" works as well
-        return (int16)(s / 32767);
-    }
-
-    ILINE Vec4sf tPackF2Bv(const Vec4& v)
-    {
-        Vec4sf vs;
-
-        vs.x = tPackF2B(v.x);
-        vs.y = tPackF2B(v.y);
-        vs.z = tPackF2B(v.z);
-        vs.w = tPackF2B(v.w);
-
-        return vs;
-    }
-
-    ILINE Vec4sf tPackF2Bv(const Vec3& v)
-    {
-        Vec4sf vs;
-
-        vs.x = tPackF2B(v.x);
-        vs.y = tPackF2B(v.y);
-        vs.z = tPackF2B(v.z);
-        vs.w = tPackF2B(1.0f);
-
-        return vs;
-    }
-
-    ILINE Vec4 tPackB2F(const Vec4sf& v)
-    {
-        Vec4 vs;
-
-        vs.x = tPackB2F(v.x);
-        vs.y = tPackB2F(v.y);
-        vs.z = tPackB2F(v.z);
-        vs.w = tPackB2F(v.w);
-
-        return vs;
-    }
-
-    ILINE void tPackB2F(const Vec4sf& v, Vec4& vDst)
-    {
-        vDst.x = tPackB2F(v.x);
-        vDst.y = tPackB2F(v.y);
-        vDst.z = tPackB2F(v.z);
-        vDst.w = 1.0f;
-    }
-
-    ILINE void tPackB2FScale(const Vec4sf& v, Vec4& vDst, const Vec3& vScale)
-    {
-        vDst.x = (float)v.x * vScale.x;
-        vDst.y = (float)v.y * vScale.y;
-        vDst.z = (float)v.z * vScale.z;
-        vDst.w = 1.0f;
-    }
-
-    ILINE void tPackB2FScale(const Vec4sf& v, Vec3& vDst, const Vec3& vScale)
-    {
-        vDst.x = (float)v.x * vScale.x;
-        vDst.y = (float)v.y * vScale.y;
-        vDst.z = (float)v.z * vScale.z;
-    }
-
-    ILINE void tPackB2F(const Vec4sf& v, Vec3& vDst)
-    {
-        vDst.x = tPackB2F(v.x);
-        vDst.y = tPackB2F(v.y);
-        vDst.z = tPackB2F(v.z);
-    }
-};
-
-//=============================================================
-// Pip => Graphics Pipeline structures, used for inputs for the GPU's Input Assembler
-// These structures are optimized for fast decoding (ALU and bandwidth) and
-// might be slow to encode on-the-fly
-
-struct SPipTangents
-{
-    SPipTangents() {}
-
-private:
-    Vec4sf Tangent;
-    Vec4sf Bitangent;
-
-public:
-    explicit SPipTangents(const Vec4sf& othert, const Vec4sf& otherb, const int16& othersign)
-    {
-        using namespace PackingSNorm;
-        Tangent   = othert;
-        Tangent.w   = PackingSNorm::tPackS2B(othersign);
-        Bitangent = otherb;
-        Bitangent.w = PackingSNorm::tPackS2B(othersign);
-    }
-
-    explicit SPipTangents(const Vec4sf& othert, const Vec4sf& otherb, const SPipTangents& othersign)
-    {
-        Tangent   = othert;
-        Tangent.w   = othersign.Tangent.w;
-        Bitangent = otherb;
-        Bitangent.w = othersign.Bitangent.w;
-    }
-
-    explicit SPipTangents(const Vec4sf& othert, const Vec4sf& otherb)
-    {
-        Tangent   = othert;
-        Bitangent = otherb;
-    }
-
-    explicit SPipTangents(const Vec3& othert, const Vec3& otherb, const int16& othersign)
-    {
-        Tangent   = Vec4sf(PackingSNorm::tPackF2B(othert.x), PackingSNorm::tPackF2B(othert.y), PackingSNorm::tPackF2B(othert.z), PackingSNorm::tPackS2B(othersign));
-        Bitangent = Vec4sf(PackingSNorm::tPackF2B(otherb.x), PackingSNorm::tPackF2B(otherb.y), PackingSNorm::tPackF2B(otherb.z), PackingSNorm::tPackS2B(othersign));
-    }
-
-    explicit SPipTangents(const Vec3& othert, const Vec3& otherb, const SPipTangents& othersign)
-    {
-        Tangent   = Vec4sf(PackingSNorm::tPackF2B(othert.x), PackingSNorm::tPackF2B(othert.y), PackingSNorm::tPackF2B(othert.z), othersign.Tangent.w);
-        Bitangent = Vec4sf(PackingSNorm::tPackF2B(otherb.x), PackingSNorm::tPackF2B(otherb.y), PackingSNorm::tPackF2B(otherb.z), othersign.Bitangent.w);
-    }
-
-    explicit SPipTangents(const Quat& other, const int16& othersign)
-    {
-        Vec3 othert = other.GetColumn0();
-        Vec3 otherb = other.GetColumn1();
-
-        Tangent   = Vec4sf(PackingSNorm::tPackF2B(othert.x), PackingSNorm::tPackF2B(othert.y), PackingSNorm::tPackF2B(othert.z), PackingSNorm::tPackS2B(othersign));
-        Bitangent = Vec4sf(PackingSNorm::tPackF2B(otherb.x), PackingSNorm::tPackF2B(otherb.y), PackingSNorm::tPackF2B(otherb.z), PackingSNorm::tPackS2B(othersign));
-    }
-
-    void ExportTo(Vec4sf& othert, Vec4sf& otherb) const
-    {
-        othert = Tangent;
-        otherb = Bitangent;
-    }
-
-    // get normal tangent and bitangent vectors
-    void GetTB(Vec4& othert, Vec4& otherb) const
-    {
-        othert = PackingSNorm::tPackB2F(Tangent);
-        otherb = PackingSNorm::tPackB2F(Bitangent);
-    }
-
-    // get normal vector (perpendicular to tangent and bitangent plane)
-    ILINE Vec3 GetN() const
-    {
-        Vec4 tng, btg;
-        GetTB(tng, btg);
-
-        Vec3 tng3(tng.x, tng.y, tng.z),
-        btg3(btg.x, btg.y, btg.z);
-
-        // assumes w 1 or -1
-        return tng3.Cross(btg3) * tng.w;
-    }
-
-    // get normal vector (perpendicular to tangent and bitangent plane)
-    void GetN(Vec3& othern) const
-    {
-        othern = GetN();
-    }
-
-    // get the tangent-space basis as individual normal vectors (tangent, bitangent and normal)
-    void GetTBN(Vec3& othert, Vec3& otherb, Vec3& othern) const
-    {
-        Vec4 tng, btg;
-        GetTB(tng, btg);
-
-        Vec3 tng3(tng.x, tng.y, tng.z),
-        btg3(btg.x, btg.y, btg.z);
-
-        // assumes w 1 or -1
-        othert = tng3;
-        otherb = btg3;
-        othern = tng3.Cross(btg3) * tng.w;
-    }
-
-    // get normal vector sign (reflection)
-    ILINE int16 GetR() const
-    {
-        return PackingSNorm::tPackB2S(Tangent.w);
-    }
-
-    // get normal vector sign (reflection)
-    void GetR(int16& sign) const
-    {
-        sign = GetR();
-    }
-
-    void TransformBy(const Matrix34& trn)
-    {
-        Vec4 tng, btg;
-        GetTB(tng, btg);
-
-        Vec3 tng3(tng.x, tng.y, tng.z),
-        btg3(btg.x, btg.y, btg.z);
-
-        tng3 = trn.TransformVector(tng3);
-        btg3 = trn.TransformVector(btg3);
-
-        *this = SPipTangents(tng3, btg3, PackingSNorm::tPackB2S(Tangent.w));
-    }
-
-    void TransformSafelyBy(const Matrix34& trn)
-    {
-        Vec4 tng, btg;
-        GetTB(tng, btg);
-
-        Vec3 tng3(tng.x, tng.y, tng.z),
-        btg3(btg.x, btg.y, btg.z);
-
-        tng3 = trn.TransformVector(tng3);
-        btg3 = trn.TransformVector(btg3);
-
-        // normalize in case "trn" wasn't length-preserving
-        tng3.Normalize();
-        btg3.Normalize();
-
-        *this = SPipTangents(tng3, btg3, PackingSNorm::tPackB2S(Tangent.w));
-    }
-};
-
-struct SPipQTangents
-{
-    SPipQTangents() {}
-
-private:
-    Vec4sf QTangent;
-
-public:
-    explicit SPipQTangents(const Vec4sf& other)
-    {
-        QTangent = other;
-    }
-
-    bool operator ==(const SPipQTangents& other) const
-    {
-        return
-            QTangent[0] == other.QTangent[0] ||
-            QTangent[1] == other.QTangent[1] ||
-            QTangent[2] == other.QTangent[2] ||
-            QTangent[3] == other.QTangent[3];
-    }
-
-    bool operator !=(const SPipQTangents& other) const
-    {
-        return !(*this == other);
-    }
-
-    // get quaternion
-    ILINE Quat GetQ() const
-    {
-        Quat q;
-
-        q.v.x = PackingSNorm::tPackB2F(QTangent.x);
-        q.v.y = PackingSNorm::tPackB2F(QTangent.y);
-        q.v.z = PackingSNorm::tPackB2F(QTangent.z);
-        q.w   = PackingSNorm::tPackB2F(QTangent.w);
-
-        return q;
-    }
-
-    // get normal vector from quaternion
-    ILINE Vec3 GetN() const
-    {
-        const Quat q = GetQ();
-        return q.GetColumn2() * (q.w < 0.0f ? -1.0f : +1.0f);
-    }
-};
-
-struct SPipNormal
-    : public Vec3
-{
-    SPipNormal() {}
-
-    explicit SPipNormal(const Vec3& othern)
-    {
-        x = othern.x;
-        y = othern.y;
-        z = othern.z;
-    }
-
-    // get normal vector
-    ILINE Vec3 GetN() const
-    {
-        return *this;
-    }
-
-    // get normal vector
-    void GetN(Vec3& othern) const
-    {
-        othern = GetN();
-    }
-
-    void TransformBy(const Matrix34& trn)
-    {
-        *this = SPipNormal(trn.TransformVector(*this));
-    }
-
-    void TransformSafelyBy(const Matrix34& trn)
-    {
-        // normalize in case "trn" wasn't length-preserving
-        *this = SPipNormal(trn.TransformVector(*this).normalize());
-    }
-};
-
-//==================================================================================================
-
-typedef SVF_P3F_C4B_T2F SAuxVertex;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Vertex Sizes
-//extern const int m_VertexSize[];
-
-//============================================================================
-// Custom vertex streams definitions
-// NOTE: If you add new stream ID also include vertex declarations creating in
-//       CD3D9Renderer::EF_InitD3DVertexDeclarations (D3DRendPipeline.cpp)
-
-// Stream IDs
-enum EStreamIDs
-{
-    VSF_GENERAL,                 // General vertex buffer
-    VSF_TANGENTS,                // Tangents buffer
-    VSF_QTANGENTS,               // Tangents buffer
-    VSF_HWSKIN_INFO,             // HW skinning buffer
-    VSF_VERTEX_VELOCITY,                // Velocity buffer
-# if ENABLE_NORMALSTREAM_SUPPORT
-    VSF_NORMALS,                 // Normals, used for skinning
-#endif
-    // <- Insert new stream IDs here
-    VSF_NUM,                     // Number of vertex streams
-
-    VSF_MORPHBUDDY = 8,          // Morphing (from m_pMorphBuddy)
-    VSF_INSTANCED = 9,           // Data is for instance stream
-    VSF_MORPHBUDDY_WEIGHTS = 15, // Morphing weights
-};
-
-//==================================================================================================================

Code/Legacy/CryCommon/WinBase.cpp

@@ -810,21 +810,6 @@ void replaceDoublePathFilename(char* szFileName)
     azstrcpy((char*)szFileName, AZ_MAX_PATH_LEN, s.c_str());
 }
 
-const int comparePathNames(const char* cpFirst, const char* cpSecond, unsigned int len)
-{
-    //create two strings and replace the \\ by / and /./ by /
-    AZStd::string first(cpFirst);
-    AZStd::string second(cpSecond);
-    adaptFilenameToLinux(first);
-    adaptFilenameToLinux(second);
-    if (strlen(cpFirst) < len || strlen(cpSecond) < len)
-    {
-        return -1;
-    }
-    unsigned int length = std::min(std::min(first.size(), second.size()), (size_t)len);    //make sure not to access invalid memory
-    return memicmp(first.c_str(), second.c_str(), length);
-}
-
 #if FIX_FILENAME_CASE
 static bool FixOnePathElement(char* path)
 {

Code/Legacy/CryCommon/crycommon_files.cmake

@@ -25,7 +25,6 @@ set(FILES
     IMiniLog.h
     IMovieSystem.h
     IProcess.h
-    IReadWriteXMLSink.h
     IRenderAuxGeom.h
     IRenderer.h
     ISerialize.h
@@ -33,7 +32,6 @@ set(FILES
     ISplines.h
     IStatObj.h
     StatObjBus.h
-    ISurfaceType.h
     ISystem.h
     ITexture.h
     ITimer.h
@@ -46,9 +44,6 @@ set(FILES
     VRCommon.h
     INavigationSystem.h
     IMNM.h
-    SFunctor.h
-    FunctorBaseFunction.h
-    FunctorBaseMember.h
     SerializationTypes.h
     CryEndian.h
     CryRandomInternal.h
@@ -56,21 +51,15 @@ set(FILES
     LCGRandom.h
     BaseTypes.h
     AnimKey.h
-    BitFiddling.h
-    Common_TypeInfo.cpp
     CryAssert.h
-    CryCrc32.h
     CryFile.h
     CryListenerSet.h
     CryLegacyAllocator.h
     CryPath.h
-    CryPodArray.h
-    CrySizer.h
     CrySystemBus.h
     CryVersion.h
     LegacyAllocator.cpp
     LegacyAllocator.h
-    MetaUtils.h
     MiniQueue.h
     MultiThread_Containers.h
     NullAudioSystem.h
@@ -82,13 +71,11 @@ set(FILES
     SimpleSerialize.h
     smartptr.h
     StlUtils.h
-    Synchronization.h
     Timer.h
     TimeValue.h
     VectorMap.h
     VertexFormats.h
     XMLBinaryHeaders.h
-    RenderBus.h
     MainThreadRenderRequestBus.h
     Cry_Matrix33.h
     Cry_Matrix34.h
@@ -106,8 +93,6 @@ set(FILES
     Cry_Vector3.h
     CryHalf.inl
     MathConversion.h
-    Cry_HWMatrix.h
-    Cry_HWVector3.h
     AndroidSpecific.h
     AppleSpecific.h
     CryAssert_Android.h

Code/Legacy/CryCommon/platform_impl.cpp

@@ -340,73 +340,6 @@ inline void CryDebugStr([[maybe_unused]] const char* format, ...)
      */
 }
 
-alignas(64) uint32  BoxSides[0x40 * 8] = {
-    0, 0, 0, 0, 0, 0, 0, 0, //00
-    0, 4, 6, 2, 0, 0, 0, 4, //01
-    7, 5, 1, 3, 0, 0, 0, 4, //02
-    0, 0, 0, 0, 0, 0, 0, 0, //03
-    0, 1, 5, 4, 0, 0, 0, 4, //04
-    0, 1, 5, 4, 6, 2, 0, 6, //05
-    7, 5, 4, 0, 1, 3, 0, 6, //06
-    0, 0, 0, 0, 0, 0, 0, 0, //07
-    7, 3, 2, 6, 0, 0, 0, 4, //08
-    0, 4, 6, 7, 3, 2, 0, 6, //09
-    7, 5, 1, 3, 2, 6, 0, 6, //0a
-    0, 0, 0, 0, 0, 0, 0, 0, //0b
-    0, 0, 0, 0, 0, 0, 0, 0, //0c
-    0, 0, 0, 0, 0, 0, 0, 0, //0d
-    0, 0, 0, 0, 0, 0, 0, 0, //0e
-    0, 0, 0, 0, 0, 0, 0, 0, //0f
-    0, 2, 3, 1, 0, 0, 0, 4, //10
-    0, 4, 6, 2, 3, 1, 0, 6, //11
-    7, 5, 1, 0, 2, 3, 0, 6, //12
-    0, 0, 0, 0, 0, 0, 0, 0, //13
-    0, 2, 3, 1, 5, 4, 0, 6, //14
-    1, 5, 4, 6, 2, 3, 0, 6, //15
-    7, 5, 4, 0, 2, 3, 0, 6, //16
-    0, 0, 0, 0, 0, 0, 0, 0, //17
-    0, 2, 6, 7, 3, 1, 0, 6, //18
-    0, 4, 6, 7, 3, 1, 0, 6, //19
-    7, 5, 1, 0, 2, 6, 0, 6, //1a
-    0, 0, 0, 0, 0, 0, 0, 0, //1b
-    0, 0, 0, 0, 0, 0, 0, 0, //1c
-    0, 0, 0, 0, 0, 0, 0, 0, //1d
-    0, 0, 0, 0, 0, 0, 0, 0, //1e
-    0, 0, 0, 0, 0, 0, 0, 0, //1f
-    7, 6, 4, 5, 0, 0, 0, 4, //20
-    0, 4, 5, 7, 6, 2, 0, 6, //21
-    7, 6, 4, 5, 1, 3, 0, 6, //22
-    0, 0, 0, 0, 0, 0, 0, 0, //23
-    7, 6, 4, 0, 1, 5, 0, 6, //24
-    0, 1, 5, 7, 6, 2, 0, 6, //25
-    7, 6, 4, 0, 1, 3, 0, 6, //26
-    0, 0, 0, 0, 0, 0, 0, 0, //27
-    7, 3, 2, 6, 4, 5, 0, 6, //28
-    0, 4, 5, 7, 3, 2, 0, 6, //29
-    6, 4, 5, 1, 3, 2, 0, 6, //2a
-    0, 0, 0, 0, 0, 0, 0, 0, //2b
-    0, 0, 0, 0, 0, 0, 0, 0, //2c
-    0, 0, 0, 0, 0, 0, 0, 0, //2d
-    0, 0, 0, 0, 0, 0, 0, 0, //2e
-    0, 0, 0, 0, 0, 0, 0, 0, //2f
-    0, 0, 0, 0, 0, 0, 0, 0, //30
-    0, 0, 0, 0, 0, 0, 0, 0, //31
-    0, 0, 0, 0, 0, 0, 0, 0, //32
-    0, 0, 0, 0, 0, 0, 0, 0, //33
-    0, 0, 0, 0, 0, 0, 0, 0, //34
-    0, 0, 0, 0, 0, 0, 0, 0, //35
-    0, 0, 0, 0, 0, 0, 0, 0, //36
-    0, 0, 0, 0, 0, 0, 0, 0, //37
-    0, 0, 0, 0, 0, 0, 0, 0, //38
-    0, 0, 0, 0, 0, 0, 0, 0, //39
-    0, 0, 0, 0, 0, 0, 0, 0, //3a
-    0, 0, 0, 0, 0, 0, 0, 0, //3b
-    0, 0, 0, 0, 0, 0, 0, 0, //3c
-    0, 0, 0, 0, 0, 0, 0, 0, //3d
-    0, 0, 0, 0, 0, 0, 0, 0, //3e
-    0, 0, 0, 0, 0, 0, 0, 0, //3f
-};
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #if defined(AZ_RESTRICTED_PLATFORM)
     #define AZ_RESTRICTED_SECTION PLATFORM_IMPL_H_SECTION_VIRTUAL_ALLOCATORS

Code/Legacy/CrySystem/CrySystem_precompiled.h

@@ -81,7 +81,6 @@
 #include <Cry_Camera.h>
 #include <smartptr.h>
 #include <Range.h>
-#include <CrySizer.h>
 #include <StlUtils.h>
 
 

Code/Legacy/CrySystem/Huffman.h

@@ -122,24 +122,6 @@ public:
     void CompressInput(const uint8* const pInput, const size_t numBytes, uint8* const pOutput, size_t* const outputSize);
     size_t UncompressInput(const uint8* const pInput, const size_t numBytes, uint8* const pOutput, const size_t maxOutputSize);
 
-    void GetMemoryUsage(ICrySizer* pSizer) const
-    {
-        pSizer->AddObject(this, sizeof(*this));
-
-        if (m_Counts != NULL)
-        {
-            pSizer->AddObject(m_Counts, sizeof(uint32), MAX_NUM_SYMBOLS);
-        }
-        if (m_TreeNodes != NULL)
-        {
-            pSizer->AddObject(m_TreeNodes, sizeof(HuffmanTreeNode), MAX_NUM_NODES);
-        }
-        if (m_Codes != NULL)
-        {
-            pSizer->AddObject(m_Codes, sizeof(HuffmanSymbolCode), MAX_NUM_CODES);
-        }
-    }
-
 private:
     void ScaleCountsAndUpdateNodes();
     int BuildTree();

Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp

@@ -37,12 +37,6 @@ namespace LegacyLevelSystem
 {
 static constexpr const char* ArchiveExtension = ".pak";
 
-void CLevelInfo::GetMemoryUsage(ICrySizer* pSizer) const
-{
-    pSizer->AddObject(m_levelName);
-    pSizer->AddObject(m_levelPath);
-}
-
 //////////////////////////////////////////////////////////////////////////
 bool CLevelInfo::OpenLevelPak()
 {
@@ -829,14 +823,6 @@ void CLevelSystem::LogLoadingTime()
     gEnv->pLog->Log(text.c_str());
 }
 
-void CLevelSystem::GetMemoryUsage(ICrySizer* pSizer) const
-{
-    pSizer->AddObject(this, sizeof(*this));
-    pSizer->AddObject(m_levelInfos);
-    pSizer->AddObject(m_levelsFolder);
-    pSizer->AddObject(m_listeners);
-}
-
 //////////////////////////////////////////////////////////////////////////
 void CLevelSystem::UnloadLevel()
 {

Code/Legacy/CrySystem/LevelSystem/LevelSystem.h

@@ -31,8 +31,6 @@ public:
     // ~ILevelInfo
 
 
-    void GetMemoryUsage(ICrySizer*) const;
-
 private:
     bool ReadInfo();
 
@@ -114,8 +112,6 @@ public:
 
     // ~ILevelSystem
 
-    void GetMemoryUsage(ICrySizer* s) const;
-
 private:
 
     float GetLastLevelLoadTime() { return m_fLastLevelLoadTime; }