scene_component_tests.cpp File Reference

#include "scene_component.hpp"
#include "glm_test_helpers.hpp"

Go to the source code of this file.

Functions
	TEST (SceneComponent, DefaultsToIdentityAndEngineAxes)
	TEST (SceneComponent, PositionAndScaleUpdateAnEvaluatedRoot)
	TEST (SceneComponent, IndependentEulerRotationsUseDegreesAndEngineSigns)
	TEST (SceneComponent, QuaternionSetterControlsOrientation)
	TEST (SceneComponent, ScalesThenRotatesThenTranslates)
	TEST (SceneComponent, ParentTranslationRotationAndScaleAffectChild)
	TEST (SceneComponent, NestedTransformsRefreshWithExplicitUpdates)
	TEST (SceneComponent, WorldRotationCombinesUnscaledParentAndChild)
	TEST (SceneComponent, DetachRetainsLocalTransform)

Function Documentation

TEST() [1/9]

TEST	(	SceneComponent	,
		DefaultsToIdentityAndEngineAxes
	)

Definition at line 12 of file scene_component_tests.cpp.

{
    SceneComponent component;
    ExpectNear(component.GetPosition(), glm::vec3(0));
    ExpectNear(component.GetScale(), glm::vec3(1));
    ExpectNear(component.GetRotation(), glm::vec3(0));
    ExpectNear(glm::mat4_cast(component.GetRotationQuat()), glm::mat4(1));
    ExpectNear(component.GetWorldMatrix(), glm::mat4(1));
    ExpectNear(component.GetForward(), glm::vec3(1, 0, 0));
    ExpectNear(component.GetRight(), glm::vec3(0, 1, 0));
    ExpectNear(component.GetUp(), glm::vec3(0, 0, 1));
}

TEST() [2/9]

TEST	(	SceneComponent	,
		DetachRetainsLocalTransform
	)

Definition at line 175 of file scene_component_tests.cpp.

{
    SceneComponent parent; 
    SceneComponent child;
    child.SetPosition(glm::vec3(1, 2, 3));
    child.SetRotation(glm::vec3(10, 20, 30));
    child.SetScale(glm::vec3(2, 3, 4));
    const glm::mat4 local = child.GetWorldMatrix();
    parent.SetPosition(glm::vec3(10, 0, 0));
    child.AttachTo(&parent);
    child.UpdateWorldMatrix();
    ExpectNear(child.GetWorldPosition(), glm::vec3(11, 2, 3));
    child.AttachTo(nullptr);
    ExpectNear(child.GetWorldMatrix(), local);
    ExpectNear(child.GetPosition(), glm::vec3(1, 2, 3));
    ExpectNear(child.GetRotation(), glm::vec3(10, 20, 30));
    ExpectNear(child.GetScale(), glm::vec3(2, 3, 4));
}

TEST() [3/9]

TEST	(	SceneComponent	,
		IndependentEulerRotationsUseDegreesAndEngineSigns
	)

Definition at line 43 of file scene_component_tests.cpp.

{
    struct Case 
    { 
        glm::vec3 angles;
        glm::vec3 forward;
        glm::vec3 right;
        glm::vec3 up; 
    };
    const Case cases[] = {
        {{90, 0, 0}, {0, 0, 1}, {0, 1, 0}, {-1, 0, 0}},
        {{0, 90, 0}, {0, -1, 0}, {1, 0, 0}, {0, 0, 1}},
        {{0, 0, 90}, {1, 0, 0}, {0, 0, -1}, {0, 1, 0}}
    };
    SceneComponent component;
    for (const auto& item : cases)
    {
        SCOPED_TRACE(::testing::Message() << "Euler " << item.angles.x << ", "
                     << item.angles.y << ", " << item.angles.z);
        component.SetRotation(item.angles);
        ExpectNear(component.GetRotation(), item.angles);
        ExpectNear(component.GetForward(), item.forward);
        ExpectNear(component.GetRight(), item.right);
        ExpectNear(component.GetUp(), item.up);
    }
}

TEST() [4/9]

TEST	(	SceneComponent	,
		NestedTransformsRefreshWithExplicitUpdates
	)

Definition at line 122 of file scene_component_tests.cpp.

{
    SceneComponent root; 
    SceneComponent child; 
    SceneComponent leaf;
    root.SetPosition(glm::vec3(10, 20, 30));
    root.SetRotation(glm::vec3(0, 90, 0));
    root.SetScale(glm::vec3(2));
    child.SetPosition(glm::vec3(1, 0, 0));
    child.SetRotation(glm::vec3(0, 90, 0));
    child.SetScale(glm::vec3(3));
    child.AttachTo(&root);
    leaf.SetPosition(glm::vec3(1, 0, 0));
    leaf.AttachTo(&child);
    root.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    leaf.UpdateWorldMatrix();
    glm::mat4 expected(1);
    expected[0][0] = -6;
    expected[1][1] = -6;
    expected[2][2] = 6;
    expected[3] = glm::vec4(4, 18, 30, 1);
    ExpectNear(leaf.GetWorldMatrix(), expected);
    ExpectNear(leaf.GetWorldPosition(), glm::vec3(4, 18, 30));
    ExpectNear(leaf.GetWorldScale(), glm::vec3(6));
 
    // Actor/Drawable update flow explicitly refreshes each world transform.
    root.SetPosition(glm::vec3(20, 30, 40));
    root.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    leaf.UpdateWorldMatrix();
    expected[3] = glm::vec4(14, 28, 40, 1);
    ExpectNear(leaf.GetWorldMatrix(), expected);
}

TEST() [5/9]

TEST	(	SceneComponent	,
		ParentTranslationRotationAndScaleAffectChild
	)

Definition at line 95 of file scene_component_tests.cpp.

{
    SceneComponent parent; 
    SceneComponent child;
    child.SetPosition(glm::vec3(1, 2, 3));
    child.AttachTo(&parent);
    parent.SetPosition(glm::vec3(10, 20, 30));
    parent.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    ExpectNear(child.GetWorldPosition(), glm::vec3(11, 22, 33));
 
    parent.SetPosition(glm::vec3(0));
    parent.SetRotation(glm::vec3(0, 90, 0));
    parent.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    ExpectNear(child.GetWorldPosition(), glm::vec3(2, -1, 3));
    ExpectNear(glm::mat4_cast(child.GetWorldRotation()), glm::mat4_cast(parent.GetRotationQuat()));
 
    parent.SetRotation(glm::vec3(0));
    parent.SetScale(glm::vec3(2, 3, 4));
    child.SetScale(glm::vec3(3, 2, 5));
    parent.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    ExpectNear(child.GetWorldPosition(), glm::vec3(2, 6, 12));
    ExpectNear(child.GetWorldScale(), glm::vec3(6, 6, 20));
}

TEST() [6/9]

TEST	(	SceneComponent	,
		PositionAndScaleUpdateAnEvaluatedRoot
	)

Definition at line 25 of file scene_component_tests.cpp.

{
    SceneComponent component;
    component.GetWorldMatrix();
    component.SetPosition(glm::vec3(3, -4, 5));
    component.SetScale(glm::vec3(2, 3, 4));
    ExpectNear(component.GetPosition(), glm::vec3(3, -4, 5));
    ExpectNear(component.GetWorldPosition(), glm::vec3(3, -4, 5));
    ExpectNear(component.GetScale(), glm::vec3(2, 3, 4));
    ExpectNear(component.GetWorldScale(), glm::vec3(2, 3, 4));
    glm::mat4 expected(1);
    expected[0][0] = 2;
    expected[1][1] = 3;
    expected[2][2] = 4;
    expected[3] = glm::vec4(3, -4, 5, 1);
    ExpectNear(component.GetWorldMatrix(), expected);
}

TEST() [7/9]

TEST	(	SceneComponent	,
		QuaternionSetterControlsOrientation
	)

Definition at line 70 of file scene_component_tests.cpp.

{
    SceneComponent component;
    const auto rotation = glm::angleAxis(glm::radians(90.0f), glm::vec3(0, 0, 1));
    component.SetRotation(rotation);
    // Compare orientations, allowing the equivalent quaternion signs q and -q.
    EXPECT_NEAR(glm::abs(glm::dot(component.GetRotationQuat(), rotation)), 1.0f, 1e-5f);
    ExpectNear(component.GetForward(), glm::vec3(0, 1, 0));
    ExpectNear(component.GetRight(), glm::vec3(-1, 0, 0));
    ExpectNear(component.GetUp(), glm::vec3(0, 0, 1));
    ExpectNear(glm::mat4_cast(component.GetWorldRotation()), glm::mat4_cast(rotation));
    // Quaternion-to-Euler conversion is deferred pending its public convention.
}

TEST() [8/9]

TEST	(	SceneComponent	,
		ScalesThenRotatesThenTranslates
	)

Definition at line 84 of file scene_component_tests.cpp.

{
    SceneComponent component;
    component.SetPosition(glm::vec3(10, 20, 30));
    component.SetRotation(glm::vec3(0, 90, 0));
    component.SetScale(glm::vec3(2, 3, 4));
    // (1,2,3) -> (2,6,12) -> (6,-2,12) -> (16,18,42).
    ExpectNear(component.GetWorldMatrix() * glm::vec4(1, 2, 3, 1), glm::vec4(16, 18, 42, 1));
    ExpectNear(component.GetWorldMatrix() * glm::vec4(1, 2, 3, 0), glm::vec4(6, -2, 12, 0));
}

TEST() [9/9]

TEST	(	SceneComponent	,
		WorldRotationCombinesUnscaledParentAndChild
	)

Definition at line 157 of file scene_component_tests.cpp.

{
    SceneComponent parent; 
    SceneComponent child;
    parent.SetRotation(glm::vec3(0, 90, 0));
    child.SetRotation(glm::vec3(0, 0, 90));
    child.AttachTo(&parent);
    parent.UpdateWorldMatrix();
    child.UpdateWorldMatrix();
    // Roll maps local Y to -Z and Z to Y; parent's yaw then maps Y to X.
    glm::mat4 expected(1);
    expected[0] = glm::vec4(0, -1, 0, 0);
    expected[1] = glm::vec4(0, 0, -1, 0);
    expected[2] = glm::vec4(1, 0, 0, 0);
    ExpectNear(glm::mat4_cast(child.GetWorldRotation()), expected);
    ExpectNear(child.GetWorldMatrix(), expected);
}