bool QtestGetYaw(){
//global yaw
Quaternion a(Vec3(0,0,1), .155);//a(1,-2,3,-2);
a.normalize();
Vec3 b(0,1,0);
b.rotateBy(a);
return fuzzyCompare(a.getYaw(), atan2(b[0], b[1]));
}
void GameScreen::Private::detectScreenType()
{
//カタログ画面か
if (fuzzyCompare(color(QRect(0, 0, 5, 5)), qRgb(45, 43, 43))) {
setScreenType(CatalogScreen);
return;
}
}
inline Point3D & Point3D::operator/= ( double divisor )
{
assert(!fuzzyCompare(divisor, 0.0));
m_x /= divisor;
m_y /= divisor;
m_z /= divisor;
return *this;
}
void tst_QRay3D::projection()
{
QFETCH(QVector3D, point);
QFETCH(QVector3D, direction);
QFETCH(QVector3D, vector);
QFETCH(QVector3D, expected);
Qt3DRender::RayCasting::QRay3D line(point, direction);
QVector3D result = line.project(vector);
QVERIFY(fuzzyCompare(result, expected));
}
int fuzzyPointCompare(double leftx, double lefty, double rightx, double righty, int corner)
{
int result = 0;
switch (corner) {
case kMoreTopLeft:
case kMoreTopRight:
result = fuzzyCompare(righty, lefty);
break;
case kMoreBottomLeft:
case kMoreBottomRight:
result = fuzzyCompare(lefty, righty);
break;
case kMoreLeftBottom:
case kMoreLeftTop:
result = fuzzyCompare(leftx, rightx);
break;
case kMoreRightBottom:
case kMoreRightTop:
result = fuzzyCompare(rightx, rightx);
break;
}
if (result == 0) {
switch (corner) {
case kMoreTopLeft:
case kMoreTopRight:
result = fuzzyCompare(leftx, rightx);
break;
case kMoreBottomLeft:
case kMoreBottomRight:
result = fuzzyCompare(rightx, leftx);
break;
case kMoreLeftBottom:
case kMoreRightBottom:
result = fuzzyCompare(lefty, righty);
break;
case kMoreLeftTop:
case kMoreRightTop:
result = fuzzyCompare(righty, lefty);
break;
}
}
return result;
}
void PageViewportController::updateMinimumScaleToFit()
{
float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize));
if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.001)) {
m_minimumScaleToFit = minimumScale;
if (!m_hadUserInteraction && !hasSuspendedContent())
m_client->setContentsScale(toViewportScale(minimumScale), true /* isInitialScale */);
m_client->didChangeViewportAttributes();
}
}
void tst_QRay3D::transform()
{
QFETCH(QVector3D, point);
QFETCH(QVector3D, direction);
QMatrix4x4 m;
m.translate(-1.0f, 2.5f, 5.0f);
m.rotate(45.0f, 1.0f, 1.0f, 1.0f);
m.scale(23.5f);
Qt3DRender::RayCasting::QRay3D ray1(point, direction);
Qt3DRender::RayCasting::QRay3D ray2(ray1);
Qt3DRender::RayCasting::QRay3D ray3;
ray1.transform(m);
ray3 = ray2.transformed(m);
QVERIFY(fuzzyCompare(ray1.origin(), ray3.origin()));
QVERIFY(fuzzyCompare(ray1.direction(), ray3.direction()));
QVERIFY(fuzzyCompare(ray1.origin(), m * point));
QVERIFY(fuzzyCompare(ray1.direction(), m.mapVector(direction)));
}
bool FuzzyCompareTestHelper::fuzzyCompare(const QVector<double> &v1, const QVector<double> &v2, const double &epsilon)
{
if (v1.size() != v2.size())
{
return false;
}
int i = 0;
bool equal = true;
while (i < v1.size() && equal)
{
equal = fuzzyCompare(v1.at(i), v2.at(i), epsilon);
++i;
}
return equal;
}
bool PageViewportController::updateMinimumScaleToFit()
{
if (m_viewportSize.isEmpty() || m_contentsSize.isEmpty())
return false;
float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize), devicePixelRatio());
if (minimumScale <= 0)
return false;
if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.001)) {
m_minimumScaleToFit = minimumScale;
if (!m_hadUserInteraction && !hasSuspendedContent())
applyScaleAfterRenderingContents(toViewportScale(minimumScale));
return true;
}
return false;
}
int SplineTester::verifyNodesM( const QPolygonF &points, const QVector<double> &m ) const
{
const int n = points.size();
int numErrors = 0;
double dx1 = points[1].x() - points[0].x();
QwtSplinePolynomial polynomial1 = QwtSplinePolynomial::fromSlopes(
dx1, points[1].y() - points[0].y(), m[0], m[1] );
for ( int i = 1; i < n - 1; i++ )
{
const double dx2 = points[i+1].x() - points[i].x();
const double dy2 = points[i+1].y() - points[i].y();
const QwtSplinePolynomial polynomial2 =
QwtSplinePolynomial::fromSlopes( dx2, dy2, m[i], m[i+1] );
const double cv1 = polynomial1.curvatureAt( dx1 );
const double cv2 = polynomial2.curvatureAt( 0.0 );
if ( !fuzzyCompare( cv1, cv2 ) )
{
#if DEBUG_ERRORS > 1
qDebug() << "invalid node condition (m)" << i <<
cv1 << cv1 << cv2 - cv1;
#endif
numErrors++;
}
dx1 = dx2;
polynomial1 = polynomial2;
}
return numErrors;
}
void PageViewportControllerClientQt::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
// This can only happen as a result of a user interaction.
ASSERT(m_controller->hadUserInteraction());
if (!targetArea.isValid())
return;
if (m_scrollChange.inProgress() || m_scaleChange.inProgress())
return;
const float margin = 10; // We want at least a little bit of margin.
QRectF endArea = targetArea.adjusted(-margin, -margin, margin, margin);
const QRectF viewportRect = m_viewportItem->boundingRect();
qreal minViewportScale = qreal(2.5);
qreal targetScale = viewportRect.size().width() / endArea.size().width();
targetScale = m_controller->innerBoundedViewportScale(qMin(minViewportScale, targetScale));
qreal currentScale = m_pageItem->contentsScale();
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), touchPoint.y());
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot - viewportHotspot / targetScale;
endPosition = m_controller->clampViewportToContents(endPosition, targetScale);
QRectF endVisibleContentRect(endPosition, viewportRect.size() / targetScale);
enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn;
// Zoom back out if attempting to scale to the same current scale, or
// attempting to continue scaling out from the inner most level.
// Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding.
if (!m_scaleStack.isEmpty() && fuzzyCompare(targetScale, currentScale, 0.01)) {
// If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out.
QRectF currentContentRect(m_viewportItem->mapRectToWebContent(viewportRect));
QRectF targetIntersection = endVisibleContentRect.intersected(targetArea);
if (!currentContentRect.contains(targetIntersection)
&& (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40
|| qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40))
zoomAction = NoZoom;
else
zoomAction = ZoomBack;
} else if (fuzzyCompare(targetScale, m_zoomOutScale, 0.01))
zoomAction = ZoomBack;
else if (targetScale < currentScale)
zoomAction = ZoomOut;
switch (zoomAction) {
case ZoomIn:
m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x() / currentScale));
m_zoomOutScale = targetScale;
break;
case ZoomBack: {
if (m_scaleStack.isEmpty()) {
targetScale = m_controller->minimumContentsScale();
endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale);
endPosition.setX(0);
m_zoomOutScale = 0;
} else {
ScaleStackItem lastScale = m_scaleStack.takeLast();
targetScale = lastScale.scale;
// Recalculate endPosition and clamp it according to the new scale.
endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale);
endPosition.setX(lastScale.xPosition);
}
endPosition = m_controller->clampViewportToContents(endPosition, targetScale);
endVisibleContentRect = QRectF(endPosition, viewportRect.size() / targetScale);
break;
}
case ZoomOut:
// Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in.
while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= targetScale)
m_scaleStack.removeLast();
m_zoomOutScale = targetScale;
break;
case NoZoom:
break;
}
animateContentRectVisible(endVisibleContentRect);
}
bool QtestLength(){
Quaternion a;
Quaternion b(1,2,3,4);
return fuzzyCompare(a.length(), 1) &&
fuzzyCompare(b.length(), 5.477225);
}
bool fuzzyQCompare(Quaternion a, Quaternion b, float diff = 0.0000005){
return fuzzyCompare(a[0], b[0], diff) &&
fuzzyCompare(a[1], b[1], diff) &&
fuzzyCompare(a[2], b[2], diff) &&
fuzzyCompare(a[3], b[3], diff) ;
}
bool QtestDot(){
Quaternion a( 1, 0, 1, 2);
Quaternion b(-1, 0, 2, 0);
return fuzzyCompare(a.dot(b), 1);
}
bool QtestNormalize(){
Quaternion a(1, 0, 1, 2);
a.normalize();
return fuzzyCompare(a.length(), 1);
}
bool FuzzyCompareTestHelper::fuzzyCompare(const Vector3 &v1, const Vector3 &v2, const double &epsilon)
{
return fuzzyCompare(v1.x, v2.x, epsilon)
&& fuzzyCompare(v1.y, v2.y, epsilon)
&& fuzzyCompare(v1.z, v2.z, epsilon);
}
bool GameScreen::Private::isVisible(PartType partType) const
{
bool ret = false;
switch (partType) {
case HeaderPart:
ret = fuzzyCompare(color(QRect(300, 3, 490, 4)), qRgb(42, 150, 163));
break;
case Ship1Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP1_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP1_2), DETAIL_CHECK_COLOR2);
break;
case Ship2Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP2_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP2_2), DETAIL_CHECK_COLOR2);
break;
case Ship3Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP3_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP3_2), DETAIL_CHECK_COLOR2);
break;
case Ship4Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP4_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP4_2), DETAIL_CHECK_COLOR2);
break;
case Ship5Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP5_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP5_2), DETAIL_CHECK_COLOR2);
break;
case Ship6Part:
ret = fuzzyCompare(color(DETAIL_RECT_SHIP6_1), DETAIL_CHECK_COLOR1)
&& fuzzyCompare(color(DETAIL_RECT_SHIP6_2), DETAIL_CHECK_COLOR2);
break;
}
return ret;
}
bool SplineTester::verifyBoundary( const QwtSpline *spline, QwtSpline::BoundaryPosition pos,
const QPolygonF &points, const QVector<double> &m ) const
{
const bool isC2 = dynamic_cast<const QwtSplineC2 *>( spline );
const int n = points.size();
const QwtSplinePolynomial polynomBegin = polynomialAt( 0, points, m );
const QwtSplinePolynomial polynomEnd = polynomialAt( n - 2, points, m );
bool ok = false;
if ( spline->boundaryType() != QwtSpline::ConditionalBoundaries )
{
// periodic or closed
const double dx = points[n-1].x() - points[n-2].x();
ok = fuzzyCompare( polynomEnd.slopeAt( dx ),
polynomBegin.slopeAt( 0.0 ) );
if ( ok && isC2 )
{
ok = fuzzyCompare( polynomEnd.curvatureAt( dx ),
polynomBegin.curvatureAt( 0.0 ) );
}
return ok;
}
switch( spline->boundaryCondition( pos ) )
{
case QwtSpline::Clamped1:
{
const double mt = ( pos == QwtSpline::AtBeginning ) ? m.first() : m.last();
ok = fuzzyCompare( mt, spline->boundaryValue( pos ) );
break;
}
case QwtSpline::Clamped2:
{
double cv;
if ( pos == QwtSpline::AtBeginning )
{
cv = polynomBegin.curvatureAt( 0.0 );
}
else
{
const double dx = points[n-1].x() - points[n-2].x();
cv = polynomEnd.curvatureAt( dx );
}
ok = fuzzyCompare( cv, spline->boundaryValue( pos ) );
break;
}
case QwtSpline::Clamped3:
{
double c3;
if ( pos == QwtSpline::AtBeginning )
c3 = polynomBegin.c3;
else
c3 = polynomEnd.c3;
ok = fuzzyCompare( 6.0 * c3, spline->boundaryValue( pos ) );
break;
}
case QwtSpline::LinearRunout:
{
const double ratio = spline->boundaryValue( pos );
if ( pos == QwtSpline::AtBeginning )
{
const double s = ( points[1].y() - points[0].y() ) /
( points[1].x() - points[0].x() );
ok = fuzzyCompare( m[0], s - ratio * ( s - m[1] ) );
}
else
{
const double s = ( points[n-1].y() - points[n-2].y() ) /
( points[n-1].x() - points[n-2].x() );
ok = fuzzyCompare( m[n-1], s - ratio * ( s - m[n-2] ) );
}
break;
}
case QwtSplineC2::CubicRunout:
{
if ( pos == QwtSpline::AtBeginning )
{
const QwtSplinePolynomial polynomBegin2 = polynomialAt( 1, points, m );
const double cv0 = polynomBegin.curvatureAt( 0.0 );
const double cv1 = polynomBegin2.curvatureAt( 0.0 );
const double cv2 = polynomBegin2.curvatureAt( points[2].x() - points[1].x() );
ok = fuzzyCompare( cv0, 2 * cv1 - cv2 );
}
else
{
const QwtSplinePolynomial polynomEnd2 = polynomialAt( n - 3, points, m );
const double cv0 = polynomEnd.curvatureAt( points[n-1].x() - points[n-2].x() );
const double cv1 = polynomEnd.curvatureAt( 0.0 );
const double cv2 = polynomEnd2.curvatureAt( 0.0 );
ok = fuzzyCompare( cv0, 2 * cv1 - cv2 );
}
break;
}
case QwtSplineC2::NotAKnot:
{
if ( pos == QwtSpline::AtBeginning )
{
const QwtSplinePolynomial polynomBegin2 = polynomialAt( 1, points, m );
ok = fuzzyCompare( polynomBegin.c3, polynomBegin2.c3 );
}
else
{
const QwtSplinePolynomial polynomEnd2 = polynomialAt( n - 3, points, m );
ok = fuzzyCompare( polynomEnd.c3, polynomEnd2.c3 );
}
break;
}
}
return ok;
}
void QtViewportHandler::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
// This can only happen as a result of a user interaction.
ASSERT(m_hadUserInteraction);
if (!targetArea.isValid())
return;
if (m_suspendCount)
return;
const int margin = 10; // We want at least a little bit of margin.
QRectF endArea = itemRectFromCSS(targetArea.adjusted(-margin, -margin, margin, margin));
const QRectF viewportRect = m_viewportItem->boundingRect();
qreal targetCSSScale = viewportRect.size().width() / endArea.size().width();
qreal endCSSScale = innerBoundedCSSScale(qMin(targetCSSScale, qreal(2.5)));
qreal endItemScale = itemScaleFromCSS(endCSSScale);
qreal currentScale = m_pageItem->contentsScale();
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), itemCoordFromCSS(touchPoint.y()));
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot * endCSSScale - viewportHotspot;
QRectF endPosRange = computePosRangeForPageItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn;
if (!m_scaleStack.isEmpty()) {
// Zoom back out if attempting to scale to the same current scale, or
// attempting to continue scaling out from the inner most level.
// Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding.
if (fuzzyCompare(endItemScale, currentScale, 0.01)) {
// If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out.
QRectF currentContentRect(m_viewportItem->contentPos() / currentScale, viewportRect.size() / currentScale);
QRectF targetIntersection = endVisibleContentRect.intersected(targetArea);
if (!currentContentRect.contains(targetIntersection) && (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40 || qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40))
zoomAction = NoZoom;
else
zoomAction = ZoomBack;
} else if (fuzzyCompare(endItemScale, m_zoomOutScale, 0.01))
zoomAction = ZoomBack;
else if (endItemScale < currentScale)
zoomAction = ZoomOut;
}
switch (zoomAction) {
case ZoomIn:
m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x()));
m_zoomOutScale = endItemScale;
break;
case ZoomBack: {
ScaleStackItem lastScale = m_scaleStack.takeLast();
endItemScale = lastScale.scale;
endCSSScale = cssScaleFromItem(lastScale.scale);
// Recalculate endPosition and bound it according to new scale.
endPosition.setY(hotspot.y() * endCSSScale - viewportHotspot.y());
endPosition.setX(lastScale.xPosition);
endPosRange = computePosRangeForPageItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
endVisibleContentRect = QRectF(endPosition / endItemScale, viewportRect.size() / endItemScale);
break;
}
case ZoomOut:
// Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in.
while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= endItemScale)
m_scaleStack.removeLast();
m_zoomOutScale = endItemScale;
break;
case NoZoom:
break;
}
animatePageItemRectVisible(endVisibleContentRect);
}
bool vec3cmp(Vec3& a, Vec3& b){
return fuzzyCompare(a[0],b[0]) &&
fuzzyCompare(a[1],b[1]) &&
fuzzyCompare(a[2],b[2]) ;
}
inline const Point3D operator/(const Point3D &p, double divisor)
{
assert(fuzzyCompare(divisor, 0.0) == false);
return Point3D(p.m_x / divisor, p.m_y / divisor, p.m_z / divisor);
}
float voltageToDegrees(float value) { // convert volt to degree (change directionWind)
// Note: The original documentation for the wind vane says 16 positions. Typically only recieve 8 positions. And 315 degrees was wrong.
// For 5V, use 1.0. For 3.3V use 0.66
#define ADJUST3OR5 1.0
if (fuzzyCompare(3.84 * ADJUST3OR5 , value))
directionWind = 0.0;
if (fuzzyCompare(1.98 * ADJUST3OR5, value))
directionWind = 22.5;
if (fuzzyCompare(2.25 * ADJUST3OR5, value))
directionWind = 45;
if (fuzzyCompare(0.41 * ADJUST3OR5, value))
directionWind = 67.5;
if (fuzzyCompare(0.45 * ADJUST3OR5, value))
directionWind = 90.0;
if (fuzzyCompare(0.32 * ADJUST3OR5, value))
directionWind = 112.5;
if (fuzzyCompare(0.90 * ADJUST3OR5, value))
directionWind = 135.0;
if (fuzzyCompare(0.62 * ADJUST3OR5, value))
directionWind = 157.5;
if (fuzzyCompare(1.40 * ADJUST3OR5, value))
directionWind = 180;
if (fuzzyCompare(1.19 * ADJUST3OR5, value))
directionWind = 202.5;
if (fuzzyCompare(3.08 * ADJUST3OR5, value))
directionWind = 225;
if (fuzzyCompare(2.93 * ADJUST3OR5, value))
directionWind = 247.5;
if (fuzzyCompare(4.62 * ADJUST3OR5, value))
directionWind = 270.0;
if (fuzzyCompare(4.04 * ADJUST3OR5, value))
directionWind = 292.5;
if (fuzzyCompare(4.34 * ADJUST3OR5, value)) // chart in documentation wrong
directionWind = 315.0;
if (fuzzyCompare(3.43 * ADJUST3OR5, value))
directionWind = 337.5;
}
float voltageToDegrees(float value, float defaultWindDirection)
{
// Note: The documenation for the wind vane says 16 positions. Only recieve 8 positions. And 370 degrees is wrong.
if (fuzzyCompare(3.84, value))
return 0.0;
if (fuzzyCompare(1.98, value))
return 22.5;
if (fuzzyCompare(2.25, value))
return 45;
if (fuzzyCompare(0.41, value))
return 67.5;
if (fuzzyCompare(0.45, value))
return 90.0;
if (fuzzyCompare(0.32, value))
return 112.5;
if (fuzzyCompare(0.90, value))
return 135.0;
if (fuzzyCompare(0.62, value))
return 157.5;
if (fuzzyCompare(1.40, value))
return 180;
if (fuzzyCompare(1.19, value))
return 202.5;
if (fuzzyCompare(3.08, value))
return 225;
if (fuzzyCompare(2.93, value))
return 247.5;
if (fuzzyCompare(4.62, value))
return 270.0;
if (fuzzyCompare(4.04, value))
return 292.5;
if (fuzzyCompare(4.34, value)) // chart in documentation wrong
return 315.0;
if (fuzzyCompare(3.43, value))
return 337.5;
Serial.print(" FAIL WIND DIRECTION");
return defaultWindDirection; // return previous value if not found
}
void tst_QVectorArray::transform()
{
QMatrix4x4 m;
m.translate(-1.0f, 2.5f, 5.0f);
m.rotate(45.0f, 1.0f, 1.0f, 1.0f);
m.scale(23.5f);
QVector2DArray v2array;
QVector3DArray v3array;
QVector4DArray v4array;
QVector2DArray v2arrayb;
QVector3DArray v3arrayb;
QVector4DArray v4arrayb;
for (int index = 0; index < 64; ++index) {
v2array.append(index * 4, index * 4 + 1);
v3array.append(index * 4, index * 4 + 1, index * 4 + 2);
v4array.append(index * 4, index * 4 + 1, index * 4 + 2,
index * 4 + 3);
v2arrayb.append(index * 4, index * 4 + 1);
v3arrayb.append(index * 4, index * 4 + 1, index * 4 + 2);
v4arrayb.append(index * 4, index * 4 + 1, index * 4 + 2,
index * 4 + 3);
}
// Perform a simple in-place transform.
v2array.transform(m);
v3array.transform(m);
v4array.transform(m);
QCOMPARE(v2array.size(), 64);
QCOMPARE(v3array.size(), 64);
QCOMPARE(v4array.size(), 64);
for (int index = 0; index < 64; ++index) {
QVector2D v2(index * 4, index * 4 + 1);
QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
QVERIFY(fuzzyCompare(v3array[index], m * v3));
QVERIFY(fuzzyCompare(v4array[index], m * v4));
}
// Increase ref-count on an array and check that detach occurs.
v2array = v2arrayb;
v3array = v3arrayb;
v4array = v4arrayb;
QVERIFY(v2array.constData() == v2arrayb.constData());
QVERIFY(v3array.constData() == v3arrayb.constData());
QVERIFY(v4array.constData() == v4arrayb.constData());
v2array.transform(m);
v3array.transform(m);
v4array.transform(m);
QVERIFY(v2array.constData() != v2arrayb.constData());
QVERIFY(v3array.constData() != v3arrayb.constData());
QVERIFY(v4array.constData() != v4arrayb.constData());
QCOMPARE(v2array.size(), 64);
QCOMPARE(v3array.size(), 64);
QCOMPARE(v4array.size(), 64);
for (int index = 0; index < 64; ++index) {
QVector2D v2(index * 4, index * 4 + 1);
QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
QVERIFY(fuzzyCompare(v3array[index], m * v3));
QVERIFY(fuzzyCompare(v4array[index], m * v4));
QVERIFY(fuzzyCompare(v2arrayb[index], v2));
QVERIFY(fuzzyCompare(v3arrayb[index], v3));
QVERIFY(fuzzyCompare(v4arrayb[index], v4));
}
// Perform the test again, with translated() this time.
v2array = v2arrayb.transformed(m);
v3array = v3arrayb.transformed(m);
v4array = v4arrayb.transformed(m);
QCOMPARE(v2array.size(), 64);
QCOMPARE(v3array.size(), 64);
QCOMPARE(v4array.size(), 64);
for (int index = 0; index < 64; ++index) {
QVector2D v2(index * 4, index * 4 + 1);
QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
QVERIFY(fuzzyCompare(v3array[index], m * v3));
QVERIFY(fuzzyCompare(v4array[index], m * v4));
QVERIFY(fuzzyCompare(v2arrayb[index], v2));
QVERIFY(fuzzyCompare(v3arrayb[index], v3));
QVERIFY(fuzzyCompare(v4arrayb[index], v4));
}
}
bool FuzzyCompareTestHelper::fuzzyCompare(const QVector3D &v1, const QVector3D &v2, const double &epsilon)
{
return fuzzyCompare(v1.x(), v2.x(), epsilon)
&& fuzzyCompare(v1.y(), v2.y(), epsilon)
&& fuzzyCompare(v1.z(), v2.z(), epsilon);
}
