Files
o3de/Gems/LmbrCentral/Code/Tests/EditorMeshComponentTests.cpp
T
2021-03-08 14:30:57 -08:00

294 lines
14 KiB
C++

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include "LmbrCentral_precompiled.h"
#include <AzCore/Component/ComponentApplication.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <AzFramework/Asset/AssetSystemBus.h>
#include <AzTest/AzTest.h>
#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
#include <AzToolsFramework/ToolsComponents/TransformComponent.h>
#include <Rendering/MeshAssetHandler.h>
#include "Source/Rendering/EditorMeshComponent.h"
namespace UnitTest
{
// base physical entity which can be derived from to detect other specific use-cases
struct PhysicalEntityPlaceHolder
: public IPhysicalEntity
{
pe_type GetType() const override { return PE_NONE; }
int AddRef() override { return 0; }
int Release() override { return 0; }
int SetParams([[maybe_unused]] const pe_params* params, [[maybe_unused]] int bThreadSafe = 0) override { return 0; }
int GetParams([[maybe_unused]] pe_params* params) const override { return 0; }
int GetStatus([[maybe_unused]] pe_status* status) const override { return 0; }
int Action(const pe_action*, [[maybe_unused]] int bThreadSafe = 0) override { return 0; }
int AddGeometry([[maybe_unused]] phys_geometry* pgeom, [[maybe_unused]] pe_geomparams* params, [[maybe_unused]] int id = -1, [[maybe_unused]] int bThreadSafe = 0) override { return 0; }
void RemoveGeometry([[maybe_unused]] int id, [[maybe_unused]] int bThreadSafe = 0) override {}
PhysicsForeignData GetForeignData([[maybe_unused]] int itype = 0) const override { return PhysicsForeignData{}; }
int GetiForeignData() const override { return 0; }
int GetStateSnapshot([[maybe_unused]] class CStream& stm, [[maybe_unused]] float time_back = 0, [[maybe_unused]] int flags = 0) override { return 0; }
int GetStateSnapshot([[maybe_unused]] TSerialize ser, [[maybe_unused]] float time_back = 0, [[maybe_unused]] int flags = 0) override { return 0; }
int SetStateFromSnapshot([[maybe_unused]] class CStream& stm, [[maybe_unused]] int flags = 0) override { return 0; }
int PostSetStateFromSnapshot() override { return 0; }
unsigned int GetStateChecksum() override { return 0; }
void SetNetworkAuthority([[maybe_unused]] int authoritive = -1, [[maybe_unused]] int paused = -1) override {}
int SetStateFromSnapshot([[maybe_unused]] TSerialize ser, [[maybe_unused]] int flags = 0) override { return 0; }
int SetStateFromTypedSnapshot([[maybe_unused]] TSerialize ser, [[maybe_unused]] int type, [[maybe_unused]] int flags = 0) override { return 0; }
int GetStateSnapshotTxt([[maybe_unused]] char* txtbuf, [[maybe_unused]] int szbuf, [[maybe_unused]] float time_back = 0) override { return 0; }
void SetStateFromSnapshotTxt([[maybe_unused]] const char* txtbuf, [[maybe_unused]] int szbuf) override {}
int DoStep([[maybe_unused]] float time_interval) override { return 0; }
int DoStep([[maybe_unused]] float time_interval, [[maybe_unused]] int iCaller) override { return 0; }
void StartStep([[maybe_unused]] float time_interval) override {}
void StepBack([[maybe_unused]] float time_interval) override {}
void GetMemoryStatistics([[maybe_unused]] ICrySizer* pSizer) const override {}
};
// special test fake to validate incoming pe_params
struct PhysicalEntitySetParamsCheck
: public PhysicalEntityPlaceHolder
{
int SetParams(const pe_params* params, [[maybe_unused]] int bThreadSafe = 0) override
{
if (params->type == pe_params_pos::type_id)
{
pe_params_pos* params_pos = (pe_params_pos*)params;
Vec3 s;
if (Matrix34* m34 = params_pos->pMtx3x4)
{
s.Set(m34->GetColumn(0).len(), m34->GetColumn(1).len(), m34->GetColumn(2).len());
Matrix33 m33(m34->GetColumn(0) / s.x, m34->GetColumn(1) / s.y, m34->GetColumn(2) / s.z);
// ensure passed in params_pos->pMtx3x4 is orthonormal
// ref - see Cry_Quat.h - explicit ILINE Quat_tpl<F>(const Matrix33_tpl<F>&m)
m_isOrthonormal = m33.IsOrthonormalRH(0.1f);
}
}
return 0;
}
bool m_isOrthonormal = false;
};
class TestEditorMeshComponent
: public LmbrCentral::EditorMeshComponent
{
public:
AZ_EDITOR_COMPONENT(TestEditorMeshComponent, "{6C6B593A-1946-4239-AE16-E8B96D9835E5}", LmbrCentral::EditorMeshComponent)
static void Reflect(AZ::ReflectContext* context);
TestEditorMeshComponent() = default;
};
void TestEditorMeshComponent::Reflect(AZ::ReflectContext* context)
{
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
{
serializeContext->Class<TestEditorMeshComponent>()
->Version(0);
}
}
class EditorMeshComponentTestFixture
: public ToolsApplicationFixture
{
AZStd::unique_ptr<AZ::ComponentDescriptor> m_testMeshComponentDescriptor;
public:
void SetUpEditorFixtureImpl() override
{
AZ::SerializeContext* serializeContext = nullptr;
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
m_testMeshComponentDescriptor =
AZStd::unique_ptr<AZ::ComponentDescriptor>(TestEditorMeshComponent::CreateDescriptor());
m_testMeshComponentDescriptor->Reflect(serializeContext);
}
void TearDownEditorFixtureImpl() override
{
m_testMeshComponentDescriptor.reset();
}
};
struct MeshAssetHandlerFixture
: ScopedAllocatorSetupFixture
{
protected:
void SetUp() override
{
AZ::AllocatorInstance<AZ::PoolAllocator>::Create();
AZ::AllocatorInstance<AZ::ThreadPoolAllocator>::Create();
AZ::Data::AssetManager::Create(AZ::Data::AssetManager::Descriptor());
AZ::Data::AssetManager::Instance().SetAssetInfoUpgradingEnabled(false);
m_handler.Register();
}
void TearDown() override
{
m_handler.Unregister();
AZ::Data::AssetManager::Destroy();
AZ::AllocatorInstance<AZ::PoolAllocator>::Destroy();
AZ::AllocatorInstance<AZ::ThreadPoolAllocator>::Destroy();
}
LmbrCentral::MeshAssetHandler m_handler;
};
struct MockAssetSystemRequestHandler
: AzFramework::AssetSystemRequestBus::Handler
{
MockAssetSystemRequestHandler()
{
BusConnect();
}
~MockAssetSystemRequestHandler()
{
BusDisconnect();
}
AzFramework::AssetSystem::AssetStatus GetAssetStatusById([[maybe_unused]] const AZ::Data::AssetId& assetId) override
{
m_statusRequest = true;
return AzFramework::AssetSystem::AssetStatus_Queued;
}
MOCK_METHOD1(CompileAssetSync, AzFramework::AssetSystem::AssetStatus (const AZStd::string&));
MOCK_METHOD1(CompileAssetSync_FlushIO, AzFramework::AssetSystem::AssetStatus (const AZStd::string&));
MOCK_METHOD1(CompileAssetSyncById, AzFramework::AssetSystem::AssetStatus (const AZ::Data::AssetId&));
MOCK_METHOD1(CompileAssetSyncById_FlushIO, AzFramework::AssetSystem::AssetStatus (const AZ::Data::AssetId&));
MOCK_METHOD4(ConfigureSocketConnection, bool (const AZStd::string&, const AZStd::string&, const AZStd::string&, const AZStd::string&));
MOCK_METHOD1(Connect, bool (const char*));
MOCK_METHOD2(ConnectWithTimeout, bool (const char*, AZStd::chrono::duration<float>));
MOCK_METHOD0(Disconnect, bool ());
MOCK_METHOD1(EscalateAssetBySearchTerm, bool (AZStd::string_view));
MOCK_METHOD1(EscalateAssetByUuid, bool (const AZ::Uuid&));
MOCK_METHOD0(GetAssetProcessorPingTimeMilliseconds, float ());
MOCK_METHOD1(GetAssetStatus, AzFramework::AssetSystem::AssetStatus (const AZStd::string&));
MOCK_METHOD1(GetAssetStatus_FlushIO, AzFramework::AssetSystem::AssetStatus (const AZStd::string&));
MOCK_METHOD2(GetAssetStatusSearchType, AzFramework::AssetSystem::AssetStatus(const AZStd::string&, int));
MOCK_METHOD2(GetAssetStatusSearchType_FlushIO, AzFramework::AssetSystem::AssetStatus(const AZStd::string&, int));
MOCK_METHOD1(GetAssetStatusById_FlushIO, AzFramework::AssetSystem::AssetStatus (const AZ::Data::AssetId&));
MOCK_METHOD3(GetUnresolvedProductReferences, void (AZ::Data::AssetId, AZ::u32&, AZ::u32&));
MOCK_METHOD0(SaveCatalog, bool ());
MOCK_METHOD1(SetAssetProcessorIP, void (const AZStd::string&));
MOCK_METHOD1(SetAssetProcessorPort, void (AZ::u16));
MOCK_METHOD1(SetBranchToken, void (const AZStd::string&));
MOCK_METHOD1(SetProjectName, void (const AZStd::string&));
MOCK_METHOD0(ShowAssetProcessor, void ());
MOCK_METHOD1(ShowInAssetProcessor, void (const AZStd::string&));
MOCK_METHOD1(WaitUntilAssetProcessorReady, bool(AZStd::chrono::duration<float>));
MOCK_METHOD1(WaitUntilAssetProcessorConnected, bool(AZStd::chrono::duration<float>));
MOCK_METHOD1(WaitUntilAssetProcessorDisconnected, bool(AZStd::chrono::duration<float>));
MOCK_METHOD0(AssetProcessorIsReady, bool());
MOCK_METHOD0(ConnectedWithAssetProcessor, bool());
MOCK_METHOD0(DisconnectedWithAssetProcessor, bool());
MOCK_METHOD0(NegotiationWithAssetProcessorFailed, bool());
MOCK_METHOD0(StartDisconnectingAssetProcessor, void());
MOCK_METHOD1(EstablishAssetProcessorConnection, bool(const AzFramework::AssetSystem::ConnectionSettings&));
MOCK_METHOD3(AppendAssetToPrioritySet, bool (const AZStd::string&, const AZ::Uuid&, uint32_t));
MOCK_METHOD3(AppendAssetsToPrioritySet, bool (const AZStd::string&, const AZStd::vector<AZ::Uuid>&, uint32_t));
MOCK_METHOD2(RemoveAssetFromPrioritySet, bool (const AZStd::string&, const AZ::Uuid&));
MOCK_METHOD2(RemoveAssetsFromPrioritySet, bool (const AZStd::string&, const AZStd::vector<AZ::Uuid>&));
bool m_statusRequest = false;
};
struct MockCatalog
: AZ::Data::AssetCatalogRequestBus::Handler
{
MockCatalog()
{
BusConnect();
}
~MockCatalog()
{
BusDisconnect();
}
AZ::Data::AssetId GetAssetIdByPath(const char*, const AZ::Data::AssetType&, bool) override
{
m_generatedId = AZ::Data::AssetId(AZ::Uuid::CreateRandom(), 1234);
return m_generatedId;
}
MOCK_METHOD1(GetAssetInfoById, AZ::Data::AssetInfo (const AZ::Data::AssetId&));
MOCK_METHOD1(AddAssetType, void (const AZ::Data::AssetType&));
MOCK_METHOD1(AddDeltaCatalog, bool (AZStd::shared_ptr<AzFramework::AssetRegistry>));
MOCK_METHOD1(AddExtension, void (const char*));
MOCK_METHOD0(ClearCatalog, void ());
MOCK_METHOD5(CreateBundleManifest, bool (const AZStd::string&, const AZStd::vector<AZStd::string>&, const AZStd::string&, int, const AZStd::vector<AZStd::string>&));
MOCK_METHOD2(CreateDeltaCatalog, bool (const AZStd::vector<AZStd::string>&, const AZStd::string&));
MOCK_METHOD0(DisableCatalog, void ());
MOCK_METHOD1(EnableCatalogForAsset, void (const AZ::Data::AssetType&));
MOCK_METHOD3(EnumerateAssets, void (BeginAssetEnumerationCB, AssetEnumerationCB, EndAssetEnumerationCB));
MOCK_METHOD1(GenerateAssetIdTEMP, AZ::Data::AssetId (const char*));
MOCK_METHOD1(GetAllProductDependencies, AZ::Outcome<AZStd::vector<AZ::Data::ProductDependency>, AZStd::string> (const AZ::Data::AssetId&));
MOCK_METHOD3(GetAllProductDependenciesFilter, AZ::Outcome<AZStd::vector<AZ::Data::ProductDependency>, AZStd::string> (const AZ::Data::AssetId&, const AZStd::unordered_set<AZ::Data::AssetId>&, const AZStd::vector<AZStd::string>&));
MOCK_METHOD1(GetAssetPathById, AZStd::string (const AZ::Data::AssetId&));
MOCK_METHOD1(GetDirectProductDependencies, AZ::Outcome<AZStd::vector<AZ::Data::ProductDependency>, AZStd::string> (const AZ::Data::AssetId&));
MOCK_METHOD1(GetHandledAssetTypes, void (AZStd::vector<AZ::Data::AssetType>&));
MOCK_METHOD0(GetRegisteredAssetPaths, AZStd::vector<AZStd::string> ());
MOCK_METHOD2(InsertDeltaCatalog, bool (AZStd::shared_ptr<AzFramework::AssetRegistry>, size_t));
MOCK_METHOD2(InsertDeltaCatalogBefore, bool (AZStd::shared_ptr<AzFramework::AssetRegistry>, AZStd::shared_ptr<AzFramework::AssetRegistry>));
MOCK_METHOD1(LoadCatalog, bool (const char*));
MOCK_METHOD2(RegisterAsset, void (const AZ::Data::AssetId&, AZ::Data::AssetInfo&));
MOCK_METHOD1(RemoveDeltaCatalog, bool (AZStd::shared_ptr<AzFramework::AssetRegistry>));
MOCK_METHOD1(SaveCatalog, bool (const char*));
MOCK_METHOD0(StartMonitoringAssets, void ());
MOCK_METHOD0(StopMonitoringAssets, void ());
MOCK_METHOD1(UnregisterAsset, void (const AZ::Data::AssetId&));
AZ::Data::AssetId m_generatedId{};
};
struct MockAssetData
: LmbrCentral::MeshAsset
{
MockAssetData(AZ::Data::AssetId assetId)
{
m_assetId = assetId;
}
};
TEST_F(MeshAssetHandlerFixture, LoadAsset_StillInQueue_LoadsSubstituteAsset)
{
MockAssetSystemRequestHandler assetSystem;
MockCatalog catalog;
AZ::Data::AssetId assetId(AZ::Uuid::CreateRandom(), 0);
AZ::Data::Asset<AZ::Data::AssetData> asset(aznew MockAssetData(assetId), AZ::Data::AssetLoadBehavior::Default);
auto substituteAssetId = m_handler.AssetMissingInCatalog(asset);
ASSERT_TRUE(assetSystem.m_statusRequest);
ASSERT_TRUE(catalog.m_generatedId.IsValid());
ASSERT_EQ(substituteAssetId, catalog.m_generatedId);
}
} // namespace UnitTest