Changeset 273381 in webkit


Ignore:
Timestamp:
Feb 24, 2021 5:09:49 AM (3 years ago)
Author:
commit-queue@webkit.org
Message:

Implement WebXR getViewport
​https://bugs.webkit.org/show_bug.cgi?id=222270

Patch by Imanol Fernandez <imanol> on 2021-02-24
Reviewed by Sergio Villar Senin.

LayoutTests/imported/w3c:

Update WebXR Viewport test expectations.

  • web-platform-tests/webxr/xrViewport_valid.https-expected.txt: Added.
  • web-platform-tests/webxr/xrWebGLLayer_viewports.https-expected.txt: Added.

Source/WebCore:

  • Modules/webxr/WebXRFrame.cpp:

(WebCore::WebXRFrame::getViewerPose): set WebXRView viewport modifiable value.

  • Modules/webxr/WebXRFrame.h:

(WebCore::WebXRFrame::isAnimationFrame const): add method.

  • Modules/webxr/WebXRSession.cpp: Implement supportsViewportScaling().

(WebCore::WebXRSession::supportsViewportScaling const):

  • Modules/webxr/WebXRSession.h:
  • Modules/webxr/WebXRView.cpp: Add viewport scale data.

(WebCore::WebXRView::create):
(WebCore::WebXRView::WebXRView):
(WebCore::WebXRView::recommendedViewportScale const):
(WebCore::WebXRView::requestViewportScale):

  • Modules/webxr/WebXRView.h:

(WebCore::WebXRView::frame const):
(WebCore::WebXRView::currentViewportScale const):
(WebCore::WebXRView::setCurrentViewportScale):
(WebCore::WebXRView::requestedViewportScale const):
(WebCore::WebXRView::isViewportModifiable const):
(WebCore::WebXRView::setViewportModifiable):

  • Modules/webxr/WebXRView.idl: add requestViewportScale() and recommendedViewportScale.
  • Modules/webxr/WebXRViewport.cpp: Implement viewport rect values.

(WebCore::WebXRViewport::create):
(WebCore::WebXRViewport::WebXRViewport):

  • Modules/webxr/WebXRViewport.h:

(WebCore::WebXRViewport::x const):
(WebCore::WebXRViewport::y const):
(WebCore::WebXRViewport::width const):
(WebCore::WebXRViewport::height const):
(WebCore::WebXRViewport::updateViewport):

  • Modules/webxr/WebXRWebGLLayer.cpp: Implement getViewport()

(WebCore::WebXRWebGLLayer::WebXRWebGLLayer):
(WebCore::m_rightViewport):
(WebCore::WebXRWebGLLayer::getViewport):

  • Modules/webxr/WebXRWebGLLayer.h:
  • Modules/webxr/WebXRWebGLLayer.idl: Add MayThrowException
  • platform/xr/PlatformXR.h: Add supportsViewportScaling method

(PlatformXR::Device::supportsViewportScaling const):

LayoutTests:

Update WebXR Viewport test expectations.

  • platform/wpe/TestExpectations:
Location:
trunk
Files:
2 added
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r273380 r273381  
     12021-02-24  Imanol Fernandez  <ifernandez@igalia.com>
     2
     3        Implement WebXR getViewport
     4        https://bugs.webkit.org/show_bug.cgi?id=222270
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        Update WebXR Viewport test expectations.
     9
     10        * platform/wpe/TestExpectations:
     11
    1122021-02-17  Sergio Villar Senin  <svillar@igalia.com>
    213

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r273261 r273381  
     12021-02-24  Imanol Fernandez  <ifernandez@igalia.com>
     2
     3        Implement WebXR getViewport
     4        https://bugs.webkit.org/show_bug.cgi?id=222270
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        Update WebXR Viewport test expectations.
     9
     10        * web-platform-tests/webxr/xrViewport_valid.https-expected.txt: Added.
     11        * web-platform-tests/webxr/xrWebGLLayer_viewports.https-expected.txt: Added.
     12
    1132021-02-22  Ryan Haddad  <ryanhaddad@apple.com>
    214

  • trunk/LayoutTests/platform/wpe/TestExpectations

    r273228 r273381  
    648648imported/w3c/web-platform-tests/webxr/xrView_match.https.html [ Pass ]
    649649imported/w3c/web-platform-tests/webxr/xrView_oneframeupdate.https.html [ Pass ]
    650 webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrWebGLLayer_constructor.https.html [ Pass ]
    651 webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrWebGLLayer_framebuffer_sameObject.https.html [ Pass ]
    652650imported/w3c/web-platform-tests/webxr/navigator_xr_sameObject.https.html [ Pass ]
    653651imported/w3c/web-platform-tests/webxr/xrReferenceSpace_originOffset_viewer.https.html [ Pass ]
    … …  
    667665imported/w3c/web-platform-tests/webxr/xrSession_requestReferenceSpace.https.html [ Pass ]
    668666imported/w3c/web-platform-tests/webxr/xrSession_viewer_referenceSpace.https.html [ Pass ]
     667imported/w3c/web-platform-tests/webxr/xrViewport_valid.https.html [ Pass ]
     668imported/w3c/web-platform-tests/webxr/xrWebGLLayer_constructor.https.html [ Pass ]
     669imported/w3c/web-platform-tests/webxr/xrWebGLLayer_framebuffer_sameObject.https.html [ Pass ]
     670imported/w3c/web-platform-tests/webxr/xrWebGLLayer_viewports.https.html [ Pass ]
    669671imported/w3c/web-platform-tests/webxr/render_state_vertical_fov_immersive.https.html [ Pass ]
    670672imported/w3c/web-platform-tests/webxr/render_state_update.https.html [ Pass ]

  • trunk/Source/WebCore/ChangeLog

    r273380 r273381  
     12021-02-24  Imanol Fernandez  <ifernandez@igalia.com>
     2
     3        Implement WebXR getViewport
     4        https://bugs.webkit.org/show_bug.cgi?id=222270
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        * Modules/webxr/WebXRFrame.cpp:
     9        (WebCore::WebXRFrame::getViewerPose): set WebXRView viewport modifiable value.
     10        * Modules/webxr/WebXRFrame.h:
     11        (WebCore::WebXRFrame::isAnimationFrame const): add method.
     12
     13        * Modules/webxr/WebXRSession.cpp: Implement supportsViewportScaling().
     14        (WebCore::WebXRSession::supportsViewportScaling const):
     15        * Modules/webxr/WebXRSession.h:
     16
     17        * Modules/webxr/WebXRView.cpp: Add viewport scale data.
     18        (WebCore::WebXRView::create):
     19        (WebCore::WebXRView::WebXRView):
     20        (WebCore::WebXRView::recommendedViewportScale const):
     21        (WebCore::WebXRView::requestViewportScale):
     22        * Modules/webxr/WebXRView.h:
     23        (WebCore::WebXRView::frame const):
     24        (WebCore::WebXRView::currentViewportScale const):
     25        (WebCore::WebXRView::setCurrentViewportScale):
     26        (WebCore::WebXRView::requestedViewportScale const):
     27        (WebCore::WebXRView::isViewportModifiable const):
     28        (WebCore::WebXRView::setViewportModifiable):
     29
     30        * Modules/webxr/WebXRView.idl: add requestViewportScale() and recommendedViewportScale.
     31
     32        * Modules/webxr/WebXRViewport.cpp: Implement viewport rect values.
     33        (WebCore::WebXRViewport::create):
     34        (WebCore::WebXRViewport::WebXRViewport):
     35        * Modules/webxr/WebXRViewport.h:
     36        (WebCore::WebXRViewport::x const):
     37        (WebCore::WebXRViewport::y const):
     38        (WebCore::WebXRViewport::width const):
     39        (WebCore::WebXRViewport::height const):
     40        (WebCore::WebXRViewport::updateViewport):
     41
     42        * Modules/webxr/WebXRWebGLLayer.cpp: Implement getViewport()
     43        (WebCore::WebXRWebGLLayer::WebXRWebGLLayer):
     44        (WebCore::m_rightViewport):
     45        (WebCore::WebXRWebGLLayer::getViewport):
     46        * Modules/webxr/WebXRWebGLLayer.h:
     47
     48        * Modules/webxr/WebXRWebGLLayer.idl: Add MayThrowException
     49
     50        * platform/xr/PlatformXR.h: Add supportsViewportScaling method
     51        (PlatformXR::Device::supportsViewportScaling const):
     52
    1532021-02-17  Sergio Villar Senin  <svillar@igalia.com>
    254

  • trunk/Source/WebCore/Modules/webxr/WebXRFrame.cpp

    r273132 r273381  
    202202        });
    203203
    204         auto xrView = WebXRView::create(view.eye, WTFMove(transform), Float32Array::create(projection.data(), projection.size()));
     204        auto xrView = WebXRView::create(makeRef(*this), view.eye, WTFMove(transform), Float32Array::create(projection.data(), projection.size()));
     205        xrView->setViewportModifiable(m_session->supportsViewportScaling());
    205206
    206207        //  8.8. Append xrview to xrviews

  • trunk/Source/WebCore/Modules/webxr/WebXRFrame.h

    r273132 r273381  
    6262    void setActive(bool active) { m_active = active; }
    6363    bool isActive() const { return m_active; }
     64    bool isAnimationFrame() const { return m_isAnimationFrame; }
    6465
    6566    static TransformationMatrix matrixFromPose(const PlatformXR::Device::FrameData::Pose&);

  • trunk/Source/WebCore/Modules/webxr/WebXRSession.cpp

    r273132 r273381  
    307307}
    308308
     309// https://immersive-web.github.io/webxr/#view-viewport-modifiable
     310bool WebXRSession::supportsViewportScaling() const
     311{
     312    ASSERT(m_device);
     313    // Only immersive sessions support viewport scaling.
     314    return m_mode == XRSessionMode::ImmersiveVr && m_device->supportsViewportScaling();
     315}
     316
    309317// https://immersive-web.github.io/webxr/#shut-down-the-session
    310318void WebXRSession::shutdown(InitiatedBySystem initiatedBySystem)

  • trunk/Source/WebCore/Modules/webxr/WebXRSession.h

    r273132 r273381  
    8282    IntSize nativeWebGLFramebufferResolution() const;
    8383    IntSize recommendedWebGLFramebufferResolution() const;
     84    bool supportsViewportScaling() const;
    8485
    8586    // EventTarget.

  • trunk/Source/WebCore/Modules/webxr/WebXRView.cpp

    r273132 r273381  
    2929#if ENABLE(WEBXR)
    3030
     31#include "WebXRFrame.h"
    3132#include "WebXRRigidTransform.h"
    3233#include <JavaScriptCore/TypedArrayInlines.h>
    … …  
    3536namespace WebCore {
    3637
     38// Arbitrary value for minimum viewport scaling.
     39// Below this threshold the resulting viewport would be too pixelated.
     40static constexpr double kMinViewportScale = 0.1;
     41
    3742WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRView);
    3843
    39 Ref<WebXRView> WebXRView::create(XREye eye, Ref<WebXRRigidTransform>&& transform, Ref<Float32Array>&& projection)
     44Ref<WebXRView> WebXRView::create(Ref<WebXRFrame>&& frame, XREye eye, Ref<WebXRRigidTransform>&& transform, Ref<Float32Array>&& projection)
    4045{
    41     return adoptRef(*new WebXRView(eye, WTFMove(transform), WTFMove(projection)));
     46    return adoptRef(*new WebXRView(WTFMove(frame), eye, WTFMove(transform), WTFMove(projection)));
    4247}
    4348
    44 WebXRView::WebXRView(XREye eye, Ref<WebXRRigidTransform>&& transform, Ref<Float32Array>&& projection)
    45     : m_eye(eye)
     49WebXRView::WebXRView(Ref<WebXRFrame>&& frame, XREye eye, Ref<WebXRRigidTransform>&& transform, Ref<Float32Array>&& projection)
     50    : m_frame(WTFMove(frame))
     51    , m_eye(eye)
    4652    , m_transform(WTFMove(transform))
    47     , m_projection(projection)
     53    , m_projection(WTFMove(projection))
    4854{
    4955}
    … …  
    5157WebXRView::~WebXRView() = default;
    5258
     59// https://immersive-web.github.io/webxr/#dom-xrview-recommendedviewportscale
     60Optional<double> WebXRView::recommendedViewportScale() const
     61{
     62    // Return null if the system does not implement a heuristic or method for determining a recommended scale.
     63    return WTF::nullopt;
     64}
     65
     66// https://immersive-web.github.io/webxr/#dom-xrview-requestviewportscale
     67void WebXRView::requestViewportScale(Optional<double> value)
     68{
     69    if (!value || *value <= 0.0)
     70        return;
     71    m_requestedViewportScale = std::clamp(*value, kMinViewportScale, 1.0);
     72}
     73
     74
    5375} // namespace WebCore
    5476

  • trunk/Source/WebCore/Modules/webxr/WebXRView.h

    r273132 r273381  
    4040class WebXRFrame;
    4141class WebXRRigidTransform;
     42class WebXRSession;
    4243
    4344class WebXRView : public RefCounted<WebXRView> {
    4445    WTF_MAKE_ISO_ALLOCATED_EXPORT(WebXRView, WEBCORE_EXPORT);
    4546public:
    46     WEBCORE_EXPORT static Ref<WebXRView> create(XREye, Ref<WebXRRigidTransform>&&, Ref<Float32Array>&&);
     47    WEBCORE_EXPORT static Ref<WebXRView> create(Ref<WebXRFrame>&&, XREye, Ref<WebXRRigidTransform>&&, Ref<Float32Array>&&);
    4748    WEBCORE_EXPORT ~WebXRView();
    4849
     50    const WebXRFrame& frame() const { return m_frame.get(); }
    4951    XREye eye() const { return m_eye; }
    5052    const Float32Array& projectionMatrix() const { return m_projection.get(); }
    5153    const WebXRRigidTransform& transform() const { return m_transform.get(); }
    5254
     55    Optional<double> recommendedViewportScale() const;
     56    void requestViewportScale(Optional<double>);
     57
     58    double requestedViewportScale() const { return m_requestedViewportScale; }
     59    bool isViewportModifiable() const { return m_viewportModifiable; }
     60    void setViewportModifiable(bool modifiable) { m_viewportModifiable = modifiable; }
     61
    5362private:
    54     WebXRView(XREye, Ref<WebXRRigidTransform>&&, Ref<Float32Array>&&);
     63    WebXRView(Ref<WebXRFrame>&&, XREye, Ref<WebXRRigidTransform>&&, Ref<Float32Array>&&);
    5564
     65    Ref<WebXRFrame> m_frame;
    5666    XREye m_eye;
    5767    Ref<WebXRRigidTransform> m_transform;
    5868    Ref<Float32Array> m_projection;
     69    bool m_viewportModifiable { false };
     70    double m_requestedViewportScale { 1.0 };
     71
    5972};
    6073

  • trunk/Source/WebCore/Modules/webxr/WebXRView.idl

    r258498 r273381  
    3535    readonly attribute Float32Array projectionMatrix;
    3636    [SameObject] readonly attribute WebXRRigidTransform transform;
     37    readonly attribute double? recommendedViewportScale;
     38    undefined requestViewportScale(double? scale);
    3739};

  • trunk/Source/WebCore/Modules/webxr/WebXRViewport.cpp

    r258498 r273381  
    3535WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRViewport);
    3636
    37 Ref<WebXRViewport> WebXRViewport::create()
     37Ref<WebXRViewport> WebXRViewport::create(const IntRect& viewport)
    3838{
    39     return adoptRef(*new WebXRViewport);
     39    return adoptRef(*new WebXRViewport(viewport));
    4040}
    4141
    42 WebXRViewport::WebXRViewport() = default;
    43 
    44 int WebXRViewport::x() const
     42WebXRViewport::WebXRViewport(const IntRect& viewport)
     43    : m_viewport(viewport)
    4544{
    46     return 0;
    47 }
    48 
    49 int WebXRViewport::y() const
    50 {
    51     return 0;
    52 }
    53 
    54 int WebXRViewport::width() const
    55 {
    56     return 0;
    57 }
    58 
    59 int WebXRViewport::height() const
    60 {
    61     return 0;
    6245}
    6346

  • trunk/Source/WebCore/Modules/webxr/WebXRViewport.h

    r258498 r273381  
    2828#if ENABLE(WEBXR)
    2929
     30#include "IntRect.h"
    3031#include <wtf/IsoMalloc.h>
    3132#include <wtf/Ref.h>
    … …  
    3738    WTF_MAKE_ISO_ALLOCATED(WebXRViewport);
    3839public:
    39     static Ref<WebXRViewport> create();
     40    static Ref<WebXRViewport> create(const IntRect&);
    4041
    41     int x() const;
    42     int y() const;
    43     int width() const;
    44     int height() const;
     42    int x() const { return m_viewport.x(); }
     43    int y() const { return m_viewport.y(); }
     44    int width() const { return m_viewport.width(); }
     45    int height() const { return m_viewport.height(); }
     46
     47    void updateViewport(const IntRect& viewport) { m_viewport = viewport; }
    4548
    4649private:
    47     WebXRViewport();
     50    explicit WebXRViewport(const IntRect&);
     51
     52    IntRect m_viewport;
    4853};
    4954

  • trunk/Source/WebCore/Modules/webxr/WebXRWebGLLayer.cpp

    r272734 r273381  
    3838#endif
    3939#include "WebGLRenderingContextBase.h"
     40#include "WebXRFrame.h"
    4041#include "WebXRSession.h"
     42#include "WebXRView.h"
    4143#include "WebXRViewport.h"
    4244#include "XRWebGLLayerInit.h"
    … …  
    98100    , m_session(WTFMove(session))
    99101    , m_context(WTFMove(context))
     102    , m_leftViewportData({ WebXRViewport::create({ }) })
     103    , m_rightViewportData({ WebXRViewport::create({ }) })
    100104{
    101105    // 7. Initialize layer’s ignoreDepthValues as follows:
    … …  
    145149        m_framebuffer.object = nullptr;
    146150    }
    147 }
    148 
    149 WebXRWebGLLayer::~WebXRWebGLLayer() = default;
     151
     152    auto canvasElement = canvas();
     153    if (canvasElement)
     154        canvasElement->addObserver(*this);
     155}
     156
     157WebXRWebGLLayer::~WebXRWebGLLayer()
     158{
     159    auto canvasElement = canvas();
     160    if (canvasElement)
     161        canvasElement->removeObserver(*this);
     162}
    150163
    151164bool WebXRWebGLLayer::antialias() const
    … …  
    184197}
    185198
    186 RefPtr<WebXRViewport> WebXRWebGLLayer::getViewport(const WebXRView&)
    187 {
    188     return { };
     199// https://immersive-web.github.io/webxr/#dom-xrwebgllayer-getviewport
     200ExceptionOr<RefPtr<WebXRViewport>> WebXRWebGLLayer::getViewport(WebXRView& view)
     201{
     202    // 1. Let session be view’s session.
     203    // 2. Let frame be session’s animation frame.
     204    // 3. If session is not equal to layer’s session, throw an InvalidStateError and abort these steps.
     205    if (&view.frame().session() != m_session.ptr())
     206        return Exception { InvalidStateError };
     207
     208    // 4. If frame’s active boolean is false, throw an InvalidStateError and abort these steps.
     209    // 5. If view’s frame is not equal to frame, throw an InvalidStateError and abort these steps.
     210    if (!view.frame().isActive() || !view.frame().isAnimationFrame())
     211        return Exception { InvalidStateError };
     212
     213    auto& viewportData = view.eye() == XREye::Right ? m_rightViewportData : m_leftViewportData;
     214
     215    // 6. If the viewport modifiable flag is true and view’s requested viewport scale is not equal to current viewport scale:
     216    //   6.1 Set current viewport scale to requested viewport scale.
     217    //   6.2 Compute the scaled viewport.
     218    if (view.isViewportModifiable() && view.requestedViewportScale() != viewportData.currentScale) {
     219        viewportData.currentScale = view.requestedViewportScale();
     220        m_viewportsDirty = true;
     221    }
     222
     223    // 7. Set the view’s viewport modifiable flag to false.
     224    view.setViewportModifiable(false);
     225
     226    if (m_viewportsDirty)
     227        computeViewports();
     228
     229    // 8. Let viewport be the XRViewport from the list of viewport objects associated with view.
     230    // 9. Return viewport.
     231    return RefPtr<WebXRViewport>(viewportData.viewport.copyRef());
    189232}
    190233
    … …  
    214257}
    215258
     259// https://immersive-web.github.io/webxr/#xrview-obtain-a-scaled-viewport
     260void WebXRWebGLLayer::computeViewports()
     261{
     262    auto roundDown = [](double value) -> int {
     263        // Round down to integer value and ensure that the value is not zero.
     264        return std::max(1, static_cast<int>(std::floor(value)));
     265    };
     266
     267    auto width = framebufferWidth();
     268    auto height = framebufferHeight();
     269
     270    if (m_session->mode() == XRSessionMode::ImmersiveVr) {
     271        // Update left viewport
     272        auto scale = m_leftViewportData.currentScale;
     273        m_leftViewportData.viewport->updateViewport(IntRect(0, 0, roundDown(width * 0.5 * scale), roundDown(height * scale)));
     274
     275        // Update right viewport
     276        scale = m_rightViewportData.currentScale;
     277        m_rightViewportData.viewport->updateViewport(IntRect(width * 0.5, 0, roundDown(width * 0.5 * scale), roundDown(height * scale)));
     278    } else {
     279        // We reuse m_leftViewport for XREye::None.
     280        m_leftViewportData.viewport->updateViewport(IntRect(0, 0, width, height));
     281    }
     282
     283    m_viewportsDirty = false;
     284}
     285
     286void WebXRWebGLLayer::canvasResized(CanvasBase&)
     287{
     288    m_viewportsDirty = true;
     289}
     290
    216291} // namespace WebCore
    217292

  • trunk/Source/WebCore/Modules/webxr/WebXRWebGLLayer.h

    r272734 r273381  
    2828#if ENABLE(WEBXR)
    2929
     30#include "CanvasBase.h"
    3031#include "ExceptionOr.h"
    3132#include "WebXRLayer.h"
    … …  
    4950struct XRWebGLLayerInit;
    5051
    51 class WebXRWebGLLayer : public WebXRLayer {
     52class WebXRWebGLLayer : public WebXRLayer, private CanvasObserver {
    5253    WTF_MAKE_ISO_ALLOCATED(WebXRWebGLLayer);
    5354public:
    … …  
    7071    unsigned framebufferHeight() const;
    7172
    72     RefPtr<WebXRViewport> getViewport(const WebXRView&);
     73    ExceptionOr<RefPtr<WebXRViewport>> getViewport(WebXRView&);
    7374
    7475    static double getNativeFramebufferScaleFactor(const WebXRSession&);
    … …  
    8384    WebXRWebGLLayer(Ref<WebXRSession>&&, WebXRRenderingContext&&, const XRWebGLLayerInit&);
    8485
     86    void computeViewports();
    8587    static IntSize computeNativeWebGLFramebufferResolution();
    8688    static IntSize computeRecommendedWebGLFramebufferResolution();
    8789
     90    void canvasChanged(CanvasBase&, const FloatRect&) final { };
     91    void canvasResized(CanvasBase&) final;
     92    void canvasDestroyed(CanvasBase&) final { };
     93
    8894    Ref<WebXRSession> m_session;
    8995    WebXRRenderingContext m_context;
     96
     97    struct ViewportData {
     98        Ref<WebXRViewport> viewport;
     99        double currentScale { 1.0 };
     100    };
     101
     102    ViewportData m_leftViewportData;
     103    ViewportData m_rightViewportData;
    90104    bool m_antialias { false };
    91105    bool m_ignoreDepthValues { false };
    92106    bool m_isCompositionEnabled { true };
     107    bool m_viewportsDirty { true };
    93108
    94109    struct {

  • trunk/Source/WebCore/Modules/webxr/WebXRWebGLLayer.idl

    r267007 r273381  
    5050
    5151    // Methods
    52     WebXRViewport? getViewport(WebXRView view);
     52    [MayThrowException] WebXRViewport? getViewport(WebXRView view);
    5353
    5454    // Static Methods

  • trunk/Source/WebCore/platform/xr/PlatformXR.h

    r273132 r273381  
    7676
    7777    bool supportsOrientationTracking() const { return m_supportsOrientationTracking; }
     78    bool supportsViewportScaling() const { return m_supportsViewportScaling; }
    7879
    7980    virtual void initializeTrackingAndRendering(SessionMode) = 0;
    … …  
    142143
    143144    bool m_supportsOrientationTracking { false };
     145    bool m_supportsViewportScaling { false };
    144146    WeakPtr<TrackingAndRenderingClient> m_trackingAndRenderingClient;
    145147};

  • trunk/Source/WebCore/testing/WebFakeXRDevice.cpp

    r273132 r273381  
    6666}
    6767
     68WebCore::IntSize SimulatedXRDevice::recommendedResolution(PlatformXR::SessionMode)
     69{
     70    // Return at least a 2 pixel size so we can have different viewports for left and right eyes
     71    return IntSize(2, 2);
     72}
     73
    6874void SimulatedXRDevice::shutDownTrackingAndRendering()
    6975{

  • trunk/Source/WebCore/testing/WebFakeXRDevice.h

    r273132 r273381  
    8181    void scheduleOnNextFrame(Function<void()>&&);
    8282private:
     83    WebCore::IntSize recommendedResolution(PlatformXR::SessionMode) final;
    8384    void initializeTrackingAndRendering(PlatformXR::SessionMode) final { }
    8485    void shutDownTrackingAndRendering() final;
Note: See TracChangeset for help on using the changeset viewer.