qquick3dxrspatialanchor.cpp

Go to the documentation of this file.

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dxrspatialanchor_p.h"
 
#if defined(Q_OS_VISIONOS)
#include "visionos/qquick3dxranchormanager_visionos_p.h"
#else
#include "openxr/qquick3dxranchormanager_openxr_p.h"
#endif
 
QT_BEGIN_NAMESPACE
 
QQuick3DXrSpatialAnchor::QQuick3DXrSpatialAnchor(QtQuick3DXr::XrSpaceId space, QUuid &uuid, QObject *parent)
    : QObject(parent)
    , m_space(space)
    , m_uuid(uuid)
{
}
 
QQuick3DXrSpatialAnchor::~QQuick3DXrSpatialAnchor()
{
 
}
 
 
QVector3D QQuick3DXrSpatialAnchor::offset3D() const
{
    return m_offset3D;
}
 
void QQuick3DXrSpatialAnchor::setOffset3D(const QVector3D &newOffset)
{
    if (m_offset3D == newOffset)
        return;
    m_offset3D = newOffset;
    emit offset3DChanged();
}
 
QVector3D QQuick3DXrSpatialAnchor::extent3D() const
{
    return m_extent3D;
}
 
void QQuick3DXrSpatialAnchor::setExtent3D(const QVector3D &newExtent)
{
    if (m_extent3D == newExtent)
        return;
    m_extent3D = newExtent;
    emit extent3DChanged();
}
 
QVector3D QQuick3DXrSpatialAnchor::position() const
{
    return m_position;
}
 
void QQuick3DXrSpatialAnchor::setPosition(const QVector3D &newPosition)
{
    if (m_position == newPosition)
        return;
    m_position = newPosition;
    emit positionChanged();
}
 
QQuaternion QQuick3DXrSpatialAnchor::rotation() const
{
    return m_rotation;
}
 
void QQuick3DXrSpatialAnchor::setRotation(const QQuaternion &newRotation)
{
    if (m_rotation == newRotation)
        return;
    m_rotation = newRotation;
    emit rotationChanged();
}
 
QQuick3DXrSpatialAnchor::Classification QQuick3DXrSpatialAnchor::classification() const
{
    return m_classification;
}
 
void QQuick3DXrSpatialAnchor::setClassification(Classification newClassification)
{
    if (m_classification == newClassification)
        return;
    m_classification = newClassification;
    emit classificationChanged();
}
 
QString QQuick3DXrSpatialAnchor::classificationString() const
{
    return m_classificationString;
}
 
void QQuick3DXrSpatialAnchor::setClassificationString(const QString &newClassificationString)
{
    if (m_classificationString == newClassificationString)
        return;
    m_classificationString = newClassificationString;
    emit classificationStringChanged();
}
 
bool QQuick3DXrSpatialAnchor::has2DBounds() const
{
    return m_has2DBounds;
}
 
void QQuick3DXrSpatialAnchor::setBounds2D(const QVector2D &offset, const QVector2D &extent)
{
    if (qFuzzyCompare(m_offset2D, offset) && qFuzzyCompare(m_extent2D, extent))
        return;
 
    m_offset2D = offset;
    m_extent2D = extent;
 
    // FIXME: verify
    m_has2DBounds = true;
 
    emit has2DBoundsChanged();
}
 
bool QQuick3DXrSpatialAnchor::has3DBounds() const
{
    return m_has3DBounds;
}
 
void QQuick3DXrSpatialAnchor::setBounds3D(const QVector3D &offset, const QVector3D &extent)
{
    if (qFuzzyCompare(m_offset3D, offset) && qFuzzyCompare(m_extent3D, extent))
        return;
 
    m_offset3D = offset;
    m_extent3D = extent;
 
    // FIXME: Store the 3D bounds and verify
    m_has3DBounds = true;
 
    emit has3DBoundsChanged();
}
 
QVector2D QQuick3DXrSpatialAnchor::offset2D() const
{
    return m_offset2D;
}
 
QVector2D QQuick3DXrSpatialAnchor::extent2D() const
{
    return m_extent2D;
}
 
QString QQuick3DXrSpatialAnchor::identifier() const
{
    return QString::fromLatin1(m_uuid.toRfc4122());
}
 
QSet<QUuid> QQuick3DXrSpatialAnchor::roomLayoutUuids() const
{
    return m_roomLayoutUuids;
}
 
void QQuick3DXrSpatialAnchor::setRoomLayoutUuids(const QSet<QUuid> &newRoomLayoutUuids)
{
    m_roomLayoutUuids = newRoomLayoutUuids;
}
 
QSet<QUuid> QQuick3DXrSpatialAnchor::spaceContainerUuids() const
{
    return m_spaceContainerUuids;
}
 
void QQuick3DXrSpatialAnchor::setSpaceContainerUuids(const QSet<QUuid> &newSpaceContainerUuids)
{
    m_spaceContainerUuids = newSpaceContainerUuids;
}
 
QT_END_NAMESPACE