You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
289 lines
11 KiB
C++
289 lines
11 KiB
C++
/*
|
|
* Copyright (c) Contributors to the Open 3D Engine Project.
|
|
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
*
|
|
*/
|
|
|
|
#include <AzTest/AzTest.h>
|
|
#include <Mocks/ITimerMock.h>
|
|
#include <Mocks/ICryPakMock.h>
|
|
#include <Mocks/IConsoleMock.h>
|
|
#include <Mocks/ISystemMock.h>
|
|
|
|
#include <AzCore/Component/ComponentApplication.h>
|
|
#include <AzCore/Component/Entity.h>
|
|
#include <AzCore/Math/Random.h>
|
|
#include <AzCore/Memory/Memory.h>
|
|
#include <AzCore/Memory/SystemAllocator.h>
|
|
#include <AzCore/RTTI/BehaviorContext.h>
|
|
#include <AzCore/Script/ScriptContext.h>
|
|
#include <AzCore/std/chrono/clocks.h>
|
|
#include <FastNoiseSystemComponent.h>
|
|
#include <FastNoiseGradientComponent.h>
|
|
#include <FastNoiseModule.h>
|
|
#include <GradientSignal/Ebuses/GradientRequestBus.h>
|
|
#include <GradientSignal/Ebuses/GradientTransformModifierRequestBus.h>
|
|
#include <GradientSignal/Ebuses/GradientTransformRequestBus.h>
|
|
|
|
class MockGradientTransformComponent
|
|
: public AZ::Component
|
|
, private GradientSignal::GradientTransformRequestBus::Handler
|
|
, private GradientSignal::GradientTransformModifierRequestBus::Handler
|
|
{
|
|
public:
|
|
AZ_COMPONENT(MockGradientTransformComponent, "{464CF47B-7E10-4E1B-BD06-79BD2AC91399}");
|
|
|
|
static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
|
|
{
|
|
services.push_back(AZ_CRC("GradientTransformService", 0x8c8c5ecc));
|
|
}
|
|
static void Reflect([[maybe_unused]] AZ::ReflectContext* context) {}
|
|
|
|
MockGradientTransformComponent() = default;
|
|
~MockGradientTransformComponent() = default;
|
|
|
|
// AZ::Component interface
|
|
void Activate() override {}
|
|
void Deactivate() override {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//// GradientTransformRequestBus
|
|
void TransformPositionToUVW([[maybe_unused]] const AZ::Vector3& inPosition, [[maybe_unused]] AZ::Vector3& outUVW, [[maybe_unused]] const bool shouldNormalizeOutput, [[maybe_unused]] bool& wasPointRejected) const override {}
|
|
void GetGradientLocalBounds([[maybe_unused]] AZ::Aabb& bounds) const override {}
|
|
void GetGradientEncompassingBounds([[maybe_unused]] AZ::Aabb& bounds) const override {}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// GradientTransformModifierRequestBus
|
|
bool GetAllowReference() const override { return false; }
|
|
void SetAllowReference([[maybe_unused]] bool value) override {}
|
|
|
|
AZ::EntityId GetShapeReference() const override { return AZ::EntityId(); }
|
|
void SetShapeReference([[maybe_unused]] AZ::EntityId shapeReference) override {}
|
|
|
|
bool GetOverrideBounds() const override { return false; }
|
|
void SetOverrideBounds([[maybe_unused]] bool value) override {}
|
|
|
|
AZ::Vector3 GetBounds() const override { return AZ::Vector3(); }
|
|
void SetBounds([[maybe_unused]] AZ::Vector3 bounds) override {}
|
|
|
|
GradientSignal::TransformType GetTransformType() const override { return static_cast<GradientSignal::TransformType>(0); }
|
|
void SetTransformType([[maybe_unused]] GradientSignal::TransformType type) override {}
|
|
|
|
bool GetOverrideTranslate() const override { return false; }
|
|
void SetOverrideTranslate([[maybe_unused]] bool value) override {}
|
|
|
|
AZ::Vector3 GetTranslate() const override { return AZ::Vector3(); }
|
|
void SetTranslate([[maybe_unused]] AZ::Vector3 translate) override {}
|
|
|
|
bool GetOverrideRotate() const override { return false; }
|
|
void SetOverrideRotate([[maybe_unused]] bool value) override {}
|
|
|
|
AZ::Vector3 GetRotate() const override { return AZ::Vector3(); }
|
|
void SetRotate([[maybe_unused]] AZ::Vector3 rotate) override {}
|
|
|
|
bool GetOverrideScale() const override { return false; }
|
|
void SetOverrideScale([[maybe_unused]] bool value) override {}
|
|
|
|
AZ::Vector3 GetScale() const override { return AZ::Vector3(); }
|
|
void SetScale([[maybe_unused]] AZ::Vector3 scale) override {}
|
|
|
|
float GetFrequencyZoom() const override { return false; }
|
|
void SetFrequencyZoom([[maybe_unused]] float frequencyZoom) override {}
|
|
|
|
GradientSignal::WrappingType GetWrappingType() const override { return static_cast<GradientSignal::WrappingType>(0); }
|
|
void SetWrappingType([[maybe_unused]] GradientSignal::WrappingType type) override {}
|
|
|
|
bool GetIs3D() const override { return false; }
|
|
void SetIs3D([[maybe_unused]] bool value) override {}
|
|
|
|
bool GetAdvancedMode() const override { return false; }
|
|
void SetAdvancedMode([[maybe_unused]] bool value) override {}
|
|
};
|
|
|
|
struct MockGlobalEnvironment
|
|
{
|
|
MockGlobalEnvironment()
|
|
{
|
|
m_stubEnv.pTimer = &m_stubTimer;
|
|
m_stubEnv.pCryPak = &m_stubPak;
|
|
m_stubEnv.pConsole = &m_stubConsole;
|
|
m_stubEnv.pSystem = &m_stubSystem;
|
|
gEnv = &m_stubEnv;
|
|
}
|
|
|
|
~MockGlobalEnvironment()
|
|
{
|
|
gEnv = nullptr;
|
|
}
|
|
|
|
private:
|
|
SSystemGlobalEnvironment m_stubEnv;
|
|
testing::NiceMock<TimerMock> m_stubTimer;
|
|
testing::NiceMock<CryPakMock> m_stubPak;
|
|
testing::NiceMock<ConsoleMock> m_stubConsole;
|
|
testing::NiceMock<SystemMock> m_stubSystem;
|
|
};
|
|
|
|
TEST(FastNoiseTest, ComponentsWithComponentApplication)
|
|
{
|
|
AZ::ComponentApplication::Descriptor appDesc;
|
|
appDesc.m_memoryBlocksByteSize = 10 * 1024 * 1024;
|
|
appDesc.m_recordingMode = AZ::Debug::AllocationRecords::RECORD_FULL;
|
|
appDesc.m_stackRecordLevels = 20;
|
|
|
|
MockGlobalEnvironment mocks;
|
|
|
|
AZ::ComponentApplication app;
|
|
AZ::Entity* systemEntity = app.Create(appDesc);
|
|
ASSERT_TRUE(systemEntity != nullptr);
|
|
app.RegisterComponentDescriptor(FastNoiseGem::FastNoiseSystemComponent::CreateDescriptor());
|
|
systemEntity->CreateComponent<FastNoiseGem::FastNoiseSystemComponent>();
|
|
|
|
systemEntity->Init();
|
|
systemEntity->Activate();
|
|
|
|
AZ::Entity* noiseEntity = aznew AZ::Entity("fastnoise_entity");
|
|
noiseEntity->CreateComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
app.AddEntity(noiseEntity);
|
|
|
|
app.Destroy();
|
|
ASSERT_TRUE(true);
|
|
}
|
|
|
|
class FastNoiseTestApp
|
|
: public ::testing::Test
|
|
{
|
|
public:
|
|
FastNoiseTestApp()
|
|
: m_application()
|
|
, m_systemEntity(nullptr)
|
|
{
|
|
}
|
|
|
|
void SetUp() override
|
|
{
|
|
AZ::ComponentApplication::Descriptor appDesc;
|
|
appDesc.m_memoryBlocksByteSize = 10 * 1024 * 1024;
|
|
appDesc.m_recordingMode = AZ::Debug::AllocationRecords::RECORD_FULL;
|
|
appDesc.m_stackRecordLevels = 20;
|
|
|
|
AZ::ComponentApplication::StartupParameters appStartup;
|
|
appStartup.m_createStaticModulesCallback =
|
|
[](AZStd::vector<AZ::Module*>& modules)
|
|
{
|
|
modules.emplace_back(new FastNoiseGem::FastNoiseModule);
|
|
};
|
|
|
|
m_systemEntity = m_application.Create(appDesc, appStartup);
|
|
m_application.RegisterComponentDescriptor(MockGradientTransformComponent::CreateDescriptor());
|
|
m_systemEntity->Init();
|
|
m_systemEntity->Activate();
|
|
}
|
|
|
|
void TearDown() override
|
|
{
|
|
m_application.Destroy();
|
|
}
|
|
|
|
AZ::ComponentApplication m_application;
|
|
AZ::Entity* m_systemEntity;
|
|
MockGlobalEnvironment m_mocks;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// testing class to inspect protected data members in the FastNoiseGradientComponent
|
|
struct FastNoiseGradientComponentTester : public FastNoiseGem::FastNoiseGradientComponent
|
|
{
|
|
const FastNoiseGem::FastNoiseGradientConfig& GetConfig() const { return m_configuration; }
|
|
|
|
void AssertTrue(const FastNoiseGem::FastNoiseGradientConfig& cfg)
|
|
{
|
|
ASSERT_TRUE(m_configuration.m_cellularDistanceFunction == cfg.m_cellularDistanceFunction);
|
|
ASSERT_TRUE(m_configuration.m_cellularJitter == cfg.m_cellularJitter);
|
|
ASSERT_TRUE(m_configuration.m_cellularReturnType == cfg.m_cellularReturnType);
|
|
ASSERT_TRUE(m_configuration.m_fractalType == cfg.m_fractalType);
|
|
ASSERT_TRUE(m_configuration.m_frequency == cfg.m_frequency);
|
|
ASSERT_TRUE(m_configuration.m_gain == cfg.m_gain);
|
|
ASSERT_TRUE(m_configuration.m_interp == cfg.m_interp);
|
|
ASSERT_TRUE(m_configuration.m_lacunarity == cfg.m_lacunarity);
|
|
ASSERT_TRUE(m_configuration.m_noiseType == cfg.m_noiseType);
|
|
ASSERT_TRUE(m_configuration.m_octaves == cfg.m_octaves);
|
|
ASSERT_TRUE(m_configuration.m_seed == cfg.m_seed);
|
|
}
|
|
};
|
|
|
|
TEST_F(FastNoiseTestApp, FastNoise_Component)
|
|
{
|
|
AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity");
|
|
ASSERT_TRUE(noiseEntity != nullptr);
|
|
noiseEntity->CreateComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
m_application.AddEntity(noiseEntity);
|
|
|
|
FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
ASSERT_TRUE(noiseComp != nullptr);
|
|
}
|
|
|
|
TEST_F(FastNoiseTestApp, FastNoise_ComponentEbus)
|
|
{
|
|
AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity");
|
|
ASSERT_TRUE(noiseEntity != nullptr);
|
|
noiseEntity->CreateComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
noiseEntity->CreateComponent<MockGradientTransformComponent>();
|
|
|
|
noiseEntity->Init();
|
|
noiseEntity->Activate();
|
|
|
|
GradientSignal::GradientSampleParams params;
|
|
float sample = -1.0f;
|
|
|
|
GradientSignal::GradientRequestBus::EventResult(sample, noiseEntity->GetId(), &GradientSignal::GradientRequestBus::Events::GetValue, params);
|
|
ASSERT_TRUE(sample >= 0.0f);
|
|
ASSERT_TRUE(sample <= 1.0f);
|
|
}
|
|
|
|
TEST_F(FastNoiseTestApp, FastNoise_ComponentMatchesConfiguration)
|
|
{
|
|
AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity");
|
|
ASSERT_TRUE(noiseEntity != nullptr);
|
|
|
|
AZ::SimpleLcgRandom rand(AZStd::GetTimeNowMicroSecond());
|
|
|
|
FastNoiseGem::FastNoiseGradientConfig cfg;
|
|
|
|
noiseEntity->CreateComponent<FastNoiseGem::FastNoiseGradientComponent>(cfg);
|
|
noiseEntity->CreateComponent<MockGradientTransformComponent>();
|
|
|
|
m_application.AddEntity(noiseEntity);
|
|
|
|
FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
ASSERT_TRUE(noiseComp != nullptr);
|
|
reinterpret_cast<FastNoiseGradientComponentTester*>(noiseComp)->AssertTrue(cfg);
|
|
}
|
|
|
|
#if FASTNOISE_EDITOR
|
|
#include <EditorFastNoiseGradientComponent.h>
|
|
|
|
TEST_F(FastNoiseTestApp, FastNoise_EditorCreateGameEntity)
|
|
{
|
|
AZStd::unique_ptr<AZ::Entity> noiseEntity(aznew AZ::Entity("editor_noise_entity"));
|
|
ASSERT_TRUE(noiseEntity != nullptr);
|
|
|
|
FastNoiseGem::EditorFastNoiseGradientComponent editor;
|
|
auto* editorBase = static_cast<AzToolsFramework::Components::EditorComponentBase*>(&editor);
|
|
editorBase->BuildGameEntity(noiseEntity.get());
|
|
|
|
// the new game entity's ocean component should look like the default one
|
|
FastNoiseGem::FastNoiseGradientConfig cfg;
|
|
|
|
FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent<FastNoiseGem::FastNoiseGradientComponent>();
|
|
ASSERT_TRUE(noiseComp != nullptr);
|
|
reinterpret_cast<FastNoiseGradientComponentTester*>(noiseComp)->AssertTrue(cfg);
|
|
}
|
|
|
|
#endif
|
|
|
|
AZ_UNIT_TEST_HOOK(DEFAULT_UNIT_TEST_ENV);
|
|
|