mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
e0fd75b5ab
This caused us to lose our gn check certification. :( Turns out gn check was just ignoring all the header paths it didn't understand and so gn check passing for sky wasn't meaning much. I tried to straighten out some of the mess in this CL, but its going to take several more rounds of massaging before gn check passes again. On the bright side (almost) all of our headers are absolute now. Turns out my script (attached to the bug) didn't notice ../ includes but I'll fix that in the next patch. R=abarth@chromium.org BUG=435361 Review URL: https://codereview.chromium.org/746023002
494 lines
21 KiB
C++
494 lines
21 KiB
C++
/*
|
|
* Copyright (C) 2014 Google Inc. 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
|
|
*/
|
|
|
|
#include "sky/engine/config.h"
|
|
#include "sky/engine/platform/transforms/TransformOperations.h"
|
|
|
|
#include "sky/engine/platform/geometry/FloatBox.h"
|
|
#include "sky/engine/platform/geometry/FloatBoxTestHelpers.h"
|
|
#include "sky/engine/platform/transforms/IdentityTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/Matrix3DTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/MatrixTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/PerspectiveTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/RotateTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/ScaleTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/SkewTransformOperation.h"
|
|
#include "sky/engine/platform/transforms/TranslateTransformOperation.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
using namespace blink;
|
|
namespace {
|
|
|
|
static const TransformOperations identityOperations;
|
|
|
|
static void EmpiricallyTestBounds(const TransformOperations& from,
|
|
const TransformOperations& to,
|
|
const double& minProgress,
|
|
const double& maxProgress)
|
|
{
|
|
FloatBox box(200, 500, 100, 100, 300, 200);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(to.blendedBoundsForBox(box, from, minProgress, maxProgress, &bounds));
|
|
bool firstTime = true;
|
|
|
|
FloatBox empiricalBounds;
|
|
static const size_t numSteps = 10;
|
|
for (size_t step = 0; step < numSteps; ++step) {
|
|
float t = step / (numSteps - 1);
|
|
t = minProgress + (maxProgress - minProgress) * t;
|
|
TransformOperations operations = from.blend(to, t);
|
|
TransformationMatrix matrix;
|
|
operations.apply(FloatSize(0, 0), matrix);
|
|
FloatBox transformed = box;
|
|
matrix.transformBox(transformed);
|
|
|
|
if (firstTime)
|
|
empiricalBounds = transformed;
|
|
else
|
|
empiricalBounds.unionBounds(transformed);
|
|
firstTime = false;
|
|
}
|
|
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertContains, bounds, empiricalBounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedTranslatedBoundsTest)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(TranslateTransformOperation::create(Length(-30, blink::Fixed), Length(20, blink::Fixed), 15, TransformOperation::Translate3D));
|
|
toOps.operations().append(TranslateTransformOperation::create(Length(10, blink::Fixed), Length(10, blink::Fixed), 200, TransformOperation::Translate3D));
|
|
FloatBox box(0, 0, 0, 10, 10, 10);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, identityOperations, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 20, 20, 210), bounds);
|
|
|
|
EXPECT_TRUE(identityOperations.blendedBoundsForBox(box, toOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 20, 20, 210), bounds);
|
|
|
|
EXPECT_TRUE(identityOperations.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-30, 0, 0, 40, 30, 25), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-30, 10, 15, 50, 20, 195), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, -0.5, 1.25, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-50, 7.5, -77.5, 80, 27.5, 333.75), bounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, EmpiricalAnimatedTranslatedBoundsTest)
|
|
{
|
|
float testTransforms[][2][3] = {
|
|
{ { 0, 0, 0 }, { 10, 10, 0 } } ,
|
|
{ { -100, 202.5, -32.6 }, { 43.2, 56.1, 89.75 } },
|
|
{ { 43.2, 56.1, 89.75 }, { -100, 202.5, -32.6 } }
|
|
};
|
|
|
|
// All progressions for animations start and end at 0, 1 respectively,
|
|
// we can go outside of these bounds, but will always at least contain
|
|
// [0,1].
|
|
float progress[][2] = {
|
|
{ 0, 1 },
|
|
{ -.25, 1.25 }
|
|
};
|
|
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(testTransforms); ++i) {
|
|
for (size_t j = 0; j < WTF_ARRAY_LENGTH(progress); ++j) {
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(TranslateTransformOperation::create(Length(testTransforms[i][0][0], blink::Fixed), Length(testTransforms[i][0][1], blink::Fixed), testTransforms[i][0][2], TransformOperation::Translate3D));
|
|
toOps.operations().append(TranslateTransformOperation::create(Length(testTransforms[i][1][0], blink::Fixed), Length(testTransforms[i][1][1], blink::Fixed), testTransforms[i][1][2], TransformOperation::Translate3D));
|
|
EmpiricallyTestBounds(fromOps, toOps, 0, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedScaleBoundsTest)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(ScaleTransformOperation::create(4, -3, TransformOperation::Scale));
|
|
toOps.operations().append(ScaleTransformOperation::create(5, 2, TransformOperation::Scale));
|
|
|
|
FloatBox box(0, 0, 0, 10, 10, 10);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, identityOperations, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 50, 20, 10), bounds);
|
|
|
|
EXPECT_TRUE(identityOperations.blendedBoundsForBox(box, toOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 50, 20, 10), bounds);
|
|
|
|
EXPECT_TRUE(identityOperations.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, -30, 0, 40, 40, 10), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, -30, 0, 50, 50, 10), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, -0.5, 1.25, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, -55, 0, 52.5, 87.5, 10), bounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, EmpiricalAnimatedScaleBoundsTest)
|
|
{
|
|
|
|
float testTransforms[][2][3] = {
|
|
{ { 1, 1, 1 }, { 10, 10, -32}},
|
|
{ { 1, 2, 5 }, { -1, -2, -4}},
|
|
{ { 0, 0, 0 }, { 1, 2, 3}},
|
|
{ { 0, 0, 0 }, { 0, 0, 0}}
|
|
};
|
|
|
|
// All progressions for animations start and end at 0, 1 respectively,
|
|
// we can go outside of these bounds, but will always at least contain
|
|
// [0,1].
|
|
float progress[][2] = {
|
|
{ 0, 1 },
|
|
{ -.25f, 1.25f }
|
|
};
|
|
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(testTransforms); ++i) {
|
|
for (size_t j = 0; j < WTF_ARRAY_LENGTH(progress); ++j) {
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(TranslateTransformOperation::create(Length(testTransforms[i][0][0], blink::Fixed), Length(testTransforms[i][0][1], blink::Fixed), testTransforms[i][0][2], TransformOperation::Translate3D));
|
|
toOps.operations().append(TranslateTransformOperation::create(Length(testTransforms[i][1][0], blink::Fixed), Length(testTransforms[i][1][1], blink::Fixed), testTransforms[i][1][2], TransformOperation::Translate3D));
|
|
EmpiricallyTestBounds(fromOps, toOps, 0, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedRotationBounds)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(RotateTransformOperation::create(0, TransformOperation::Rotate));
|
|
toOps.operations().append(RotateTransformOperation::create(360, TransformOperation::Rotate));
|
|
float sqrt2 = sqrt(2.0f);
|
|
FloatBox box(-sqrt2, -sqrt2, 0, sqrt2, sqrt2, 0);
|
|
FloatBox bounds;
|
|
|
|
// Since we're rotating 360 degrees, any box with dimensions between 0 and
|
|
// 2 * sqrt(2) should give the same result.
|
|
float sizes[] = { 0, 0.1f, sqrt2, 2*sqrt2 };
|
|
toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds);
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(sizes); ++i) {
|
|
box.setSize(FloatPoint3D(sizes[i], sizes[i], 0));
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-2, -2, 0, 4, 4, 0), bounds);
|
|
}
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedExtremeRotationBounds)
|
|
{
|
|
// If the normal is off-plane, we can have up to 6 exrema (min/max in each
|
|
// dimension between) the endpoints of the arg. This makes sure we are
|
|
// catching all 6.
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(RotateTransformOperation::create(1, 1, 1, 30, TransformOperation::Rotate3D));
|
|
toOps.operations().append(RotateTransformOperation::create(1, 1, 1, 390, TransformOperation::Rotate3D));
|
|
|
|
FloatBox box(1, 0, 0, 0, 0, 0);
|
|
FloatBox bounds;
|
|
float min = -1 / 3.0f;
|
|
float max = 1;
|
|
float size = max - min;
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(min, min, min, size, size, size), bounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedAxisRotationBounds)
|
|
{
|
|
// We can handle rotations about a single axis. If the axes are different,
|
|
// we revert to matrix interpolation for which inflated bounds cannot be
|
|
// computed.
|
|
TransformOperations fromOps;
|
|
TransformOperations toSame;
|
|
TransformOperations toOpposite;
|
|
TransformOperations toDifferent;
|
|
fromOps.operations().append(RotateTransformOperation::create(1, 1, 1, 30, TransformOperation::Rotate3D));
|
|
toSame.operations().append(RotateTransformOperation::create(1, 1, 1, 390, TransformOperation::Rotate3D));
|
|
toOpposite.operations().append(RotateTransformOperation::create(-1, -1, -1, 390, TransformOperation::Rotate3D));
|
|
toDifferent.operations().append(RotateTransformOperation::create(1, 3, 1, 390, TransformOperation::Rotate3D));
|
|
|
|
FloatBox box(1, 0, 0, 0, 0, 0);
|
|
FloatBox bounds;
|
|
EXPECT_TRUE(toSame.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_TRUE(toOpposite.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_FALSE(toDifferent.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedOnAxisRotationBounds)
|
|
{
|
|
// If we rotate a point that is on the axis of rotation, the box should not
|
|
// change at all.
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(RotateTransformOperation::create(1, 1, 1, 30, TransformOperation::Rotate3D));
|
|
toOps.operations().append(RotateTransformOperation::create(1, 1, 1, 390, TransformOperation::Rotate3D));
|
|
|
|
FloatBox box(1, 1, 1, 0, 0, 0);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, box, bounds);
|
|
}
|
|
|
|
// This would have been best as anonymous structs, but |WTF_ARRAY_LENGTH|
|
|
// does not get along with anonymous structs once we support C++11
|
|
// WTF_ARRAY_LENGTH will automatically support anonymous structs.
|
|
|
|
struct ProblematicAxisTest {
|
|
double x;
|
|
double y;
|
|
double z;
|
|
FloatBox expected;
|
|
};
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedProblematicAxisRotationBounds)
|
|
{
|
|
// Zeros in the components of the axis osf rotation turned out to be tricky to
|
|
// deal with in practice. This function tests some potentially problematic
|
|
// axes to ensure sane behavior.
|
|
|
|
// Some common values used in the expected boxes.
|
|
float dim1 = 0.292893f;
|
|
float dim2 = sqrt(2.0f);
|
|
float dim3 = 2 * dim2;
|
|
|
|
ProblematicAxisTest tests[] = {
|
|
{ 0, 0, 0, FloatBox(1, 1, 1, 0, 0, 0) },
|
|
{ 1, 0, 0, FloatBox(1, -dim2, -dim2, 0, dim3, dim3) },
|
|
{ 0, 1, 0, FloatBox(-dim2, 1, -dim2, dim3, 0, dim3) },
|
|
{ 0, 0, 1, FloatBox(-dim2, -dim2, 1, dim3, dim3, 0) },
|
|
{ 1, 1, 0, FloatBox(dim1, dim1, -1, dim2, dim2, 2) },
|
|
{ 0, 1, 1, FloatBox(-1, dim1, dim1, 2, dim2, dim2) },
|
|
{ 1, 0, 1, FloatBox(dim1, -1, dim1, dim2, 2, dim2) }
|
|
};
|
|
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(tests); ++i) {
|
|
float x = tests[i].x;
|
|
float y = tests[i].y;
|
|
float z = tests[i].z;
|
|
TransformOperations fromOps;
|
|
fromOps.operations().append(RotateTransformOperation::create(x, y, z, 0, TransformOperation::Rotate3D));
|
|
TransformOperations toOps;
|
|
toOps.operations().append(RotateTransformOperation::create(x, y, z, 360, TransformOperation::Rotate3D));
|
|
FloatBox box(1, 1, 1, 0, 0, 0);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(
|
|
box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, tests[i].expected, bounds);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(TransformOperationsTest, BlendedBoundsForRotationEmpiricalTests)
|
|
{
|
|
float axes[][3] = {
|
|
{ 1, 1, 1 },
|
|
{ -1, -1, -1 },
|
|
{ -1, 2, 3 },
|
|
{ 1, -2, 3 },
|
|
{ 0, 0, 0 },
|
|
{ 1, 0, 0 },
|
|
{ 0, 1, 0 },
|
|
{ 0, 0, 1 },
|
|
{ 1, 1, 0 },
|
|
{ 0, 1, 1 },
|
|
{ 1, 0, 1 },
|
|
{ -1, 0, 0 },
|
|
{ 0, -1, 0 },
|
|
{ 0, 0, -1 },
|
|
{ -1, -1, 0 },
|
|
{ 0, -1, -1 },
|
|
{ -1, 0, -1 }
|
|
};
|
|
|
|
float angles[][2] = {
|
|
{ 5, 100 },
|
|
{ 10, 5 },
|
|
{ 0, 360 },
|
|
{ 20, 180 },
|
|
{ -20, -180 },
|
|
{ 180, -220 },
|
|
{ 220, 320 },
|
|
{ 1020, 1120 },
|
|
{-3200, 120 },
|
|
{-9000, -9050 }
|
|
};
|
|
|
|
float progress[][2] = {
|
|
{ 0, 1 },
|
|
{ -0.25f, 1.25f }
|
|
};
|
|
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(axes); ++i) {
|
|
for (size_t j = 0; j < WTF_ARRAY_LENGTH(angles); ++j) {
|
|
for (size_t k = 0; k < WTF_ARRAY_LENGTH(progress); ++k) {
|
|
float x = axes[i][0];
|
|
float y = axes[i][1];
|
|
float z = axes[i][2];
|
|
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
|
|
fromOps.operations().append(RotateTransformOperation::create(x, y, z, angles[j][0], TransformOperation::Rotate3D));
|
|
toOps.operations().append(RotateTransformOperation::create(x, y, z, angles[j][1], TransformOperation::Rotate3D));
|
|
EmpiricallyTestBounds(fromOps, toOps, progress[k][0], progress[k][1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteAnimatedPerspectiveBoundsTest)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(PerspectiveTransformOperation::create(10));
|
|
toOps.operations().append(PerspectiveTransformOperation::create(30));
|
|
FloatBox box(0, 0, 0, 10, 10, 10);
|
|
FloatBox bounds;
|
|
toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds);
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 15, 15, 15), bounds);
|
|
|
|
fromOps.blendedBoundsForBox(box, toOps, -0.25, 1.25, &bounds);
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-40, -40, -40, 52, 52, 52), bounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, EmpiricalAnimatedPerspectiveBoundsTest)
|
|
{
|
|
float depths[][2] = {
|
|
{ 600, 400 },
|
|
{ 800, 1000 },
|
|
{ 800, std::numeric_limits<float>::infinity() }
|
|
};
|
|
|
|
float progress[][2] = {
|
|
{ 0, 1 },
|
|
{-0.1f, 1.1f }
|
|
};
|
|
|
|
for (size_t i = 0; i < WTF_ARRAY_LENGTH(depths); ++i) {
|
|
for (size_t j = 0; j < WTF_ARRAY_LENGTH(progress); ++j) {
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
|
|
fromOps.operations().append(PerspectiveTransformOperation::create(depths[i][0]));
|
|
toOps.operations().append(PerspectiveTransformOperation::create(depths[i][1]));
|
|
|
|
EmpiricallyTestBounds(fromOps, toOps, progress[j][0], progress[j][1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(TransformOperationsTest, AnimatedSkewBoundsTest)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
fromOps.operations().append(SkewTransformOperation::create(-45, 0, TransformOperation::Skew));
|
|
toOps.operations().append(SkewTransformOperation::create(0, 45, TransformOperation::Skew));
|
|
FloatBox box(0, 0, 0, 10, 10, 10);
|
|
FloatBox bounds;
|
|
|
|
toOps.blendedBoundsForBox(box, identityOperations, 0, 1, &bounds);
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(0, 0, 0, 10, 20, 10), bounds);
|
|
|
|
identityOperations.blendedBoundsForBox(box, fromOps, 0, 1, &bounds);
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-10, 0, 0, 20, 10, 10), bounds);
|
|
|
|
toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds);
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-10, 0, 0, 20, 20, 10), bounds);
|
|
|
|
fromOps.blendedBoundsForBox(box, toOps, 0, 1, &bounds);
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-10, 0, 0, 20, 20, 10), bounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, NonCommutativeRotations)
|
|
{
|
|
TransformOperations fromOps;
|
|
fromOps.operations().append(RotateTransformOperation::create(1, 0, 0, 0, TransformOperation::Rotate3D));
|
|
fromOps.operations().append(RotateTransformOperation::create(0, 1, 0, 0, TransformOperation::Rotate3D));
|
|
TransformOperations toOps;
|
|
toOps.operations().append(RotateTransformOperation::create(1, 0, 0, 45, TransformOperation::Rotate3D));
|
|
toOps.operations().append(RotateTransformOperation::create(0, 1, 0, 135, TransformOperation::Rotate3D));
|
|
|
|
FloatBox box(0, 0, 0, 1, 1, 1);
|
|
FloatBox bounds;
|
|
|
|
double minProgress = 0;
|
|
double maxProgress = 1;
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(
|
|
box, fromOps, minProgress, maxProgress, &bounds));
|
|
|
|
TransformOperations operations = toOps.blend(fromOps, maxProgress);
|
|
TransformationMatrix blendedTransform;
|
|
operations.apply(FloatSize(0, 0), blendedTransform);
|
|
|
|
FloatPoint3D blendedPoint(0.9f, 0.9f, 0);
|
|
blendedPoint = blendedTransform.mapPoint(blendedPoint);
|
|
FloatBox expandedBounds = bounds;
|
|
expandedBounds.expandTo(blendedPoint);
|
|
|
|
ASSERT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, bounds, expandedBounds);
|
|
}
|
|
|
|
TEST(TransformOperationsTest, AbsoluteSequenceBoundsTest)
|
|
{
|
|
TransformOperations fromOps;
|
|
TransformOperations toOps;
|
|
|
|
fromOps.operations().append(TranslateTransformOperation::create(Length(1, Fixed), Length(-5, Fixed), 1, TransformOperation::Translate3D));
|
|
fromOps.operations().append(ScaleTransformOperation::create(-1, 2, 3, TransformOperation::Scale3D));
|
|
fromOps.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(4, Fixed), -1, TransformOperation::Translate3D));
|
|
|
|
toOps.operations().append(TranslateTransformOperation::create(Length(13, Fixed), Length(-1, Fixed), 5, TransformOperation::Translate3D));
|
|
toOps.operations().append(ScaleTransformOperation::create(-3, -2, 5, TransformOperation::Scale3D));
|
|
toOps.operations().append(TranslateTransformOperation::create(Length(6, Fixed), Length(-2, Fixed), 3, TransformOperation::Translate3D));
|
|
|
|
FloatBox box(1, 2, 3, 4, 4, 4);
|
|
FloatBox bounds;
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, -0.5, 1.5, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-57, -59, -1, 76, 112, 80), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-32, -25, 7, 42, 44, 48), bounds);
|
|
|
|
EXPECT_TRUE(toOps.blendedBoundsForBox(box, identityOperations, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-33, -13, 3, 57, 19, 52), bounds);
|
|
|
|
EXPECT_TRUE(identityOperations.blendedBoundsForBox(box, fromOps, 0, 1, &bounds));
|
|
EXPECT_PRED_FORMAT2(FloatBoxTest::AssertAlmostEqual, FloatBox(-7, -3, 2, 15, 23, 20), bounds);
|
|
}
|
|
|
|
} // namespace
|