@reactvision/react-viro 2.55.0 → 2.57.0

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROGameLoopListener.h

@@ -0,0 +1,125 @@
+//
+//  VROGameLoopListener.h
+//  ViroKit
+//
+//  Copyright © 2026 ReactVision. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+
+#ifndef VROGameLoopListener_h
+#define VROGameLoopListener_h
+
+#include <functional>
+#include "VROFrameListener.h"
+#include "VROTime.h"
+
+/*
+ VROGameLoopListener — thin VROFrameListener wrapper that tracks delta time and
+ elapsed time, then fires typed callbacks from the render thread.
+
+ Typical use (C++, from native bridge code):
+
+     auto loop = std::make_shared<VROGameLoopListener>();
+     loop->setOnFrameWillRender([](float dt, float elapsed) {
+         // game logic here — runs before physics and rendering
+     });
+     frameSynchronizer->addFrameListener(loop);
+
+ For fixed-step simulation (F5 addendum):
+
+     loop->setFixedHz(30);
+     loop->setOnFixedStep([](float dt) {
+         // guaranteed 1/30 s ticks
+     });
+
+ Thread safety: callbacks are invoked on the render thread. Callers are
+ responsible for marshalling to another thread if needed.
+ */
+class VROGameLoopListener : public VROFrameListener {
+public:
+    using UpdateCallback    = std::function<void(float dtSec, float elapsedSec)>;
+    using FixedStepCallback = std::function<void(float dtSec)>;
+
+    VROGameLoopListener() = default;
+    ~VROGameLoopListener() override = default;
+
+    // ── Variable-step callbacks ────────────────────────────────────────────────
+
+    void setOnFrameWillRender(UpdateCallback cb) { _onWillRender = std::move(cb); }
+    void setOnFrameDidRender(UpdateCallback cb)  { _onDidRender  = std::move(cb); }
+
+    // ── Fixed-step (F5 addendum) ───────────────────────────────────────────────
+
+    /*
+     Set the fixed simulation frequency in Hz (e.g. 30 for libsm64, 60 for typical
+     physics). Each onFrameWillRender call drains the accumulator, firing the fixed-
+     step callback as many times as needed to stay in sync with wall time.
+     A clamped dt prevents a "spiral of death" when frames are very slow.
+     */
+    void setFixedHz(float hz) {
+        _fixedHz      = hz;
+        _fixedDt      = (hz > 0.f) ? 1.f / hz : 0.f;
+        _accumulator  = 0.f;
+        _fixedEnabled = (hz > 0.f);
+    }
+    void setOnFixedStep(FixedStepCallback cb) { _onFixedStep = std::move(cb); }
+
+    // ── VROFrameListener ──────────────────────────────────────────────────────
+
+    void onFrameWillRender(const VRORenderContext &context) override {
+        double now = VROTimeCurrentMillis();
+        if (_startTime < 0.0) _startTime = _lastTime = now;
+
+        float dt      = (float)((now - _lastTime)  / 1000.0);
+        float elapsed = (float)((now - _startTime) / 1000.0);
+        _lastTime = now;
+
+        // Fixed-step drain — clamp frame dt to avoid spiral of death
+        if (_fixedEnabled && _onFixedStep && _fixedDt > 0.f) {
+            float safeDt = (dt < kMaxFrameDt) ? dt : kMaxFrameDt;
+            _accumulator += safeDt;
+            while (_accumulator >= _fixedDt) {
+                _onFixedStep(_fixedDt);
+                _accumulator -= _fixedDt;
+            }
+        }
+
+        if (_onWillRender) _onWillRender(dt, elapsed);
+    }
+
+    void onFrameDidRender(const VRORenderContext &context) override {
+        if (!_onDidRender) return;
+        double now    = VROTimeCurrentMillis();
+        float dt      = (float)((now - _lastTime)  / 1000.0);
+        float elapsed = (float)((now - _startTime) / 1000.0);
+        _onDidRender(dt, elapsed);
+    }
+
+private:
+    // Maximum frame delta clamped in fixed-step mode (prevents spiral of death
+    // if the app is paused or debugging halts the render loop).
+    static constexpr float kMaxFrameDt = 0.25f;  // 4 fps floor
+
+    UpdateCallback    _onWillRender;
+    UpdateCallback    _onDidRender;
+    FixedStepCallback _onFixedStep;
+
+    double _startTime   = -1.0;
+    double _lastTime    = -1.0;
+
+    bool  _fixedEnabled = false;
+    float _fixedHz      = 0.f;
+    float _fixedDt      = 0.f;
+    float _accumulator  = 0.f;
+};
+
+#endif /* VROGameLoopListener_h */

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROInputState.h

@@ -0,0 +1,133 @@
+//
+//  VROInputState.h
+//  ViroKit
+//
+//  Copyright © 2026 ReactVision. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+
+#ifndef VROInputState_h
+#define VROInputState_h
+
+#include <stdint.h>
+#include <mutex>
+
+/*
+ Unified controller state for game-style continuous input. Filled by zero or more
+ source adapters (virtual touch joystick, MFi/Bluetooth gamepad, device tilt,
+ voice, hand-tracking) and read by consumers (game loop, simulation adapter,
+ native modules forwarding to JS).
+
+ Independent of VROInputControllerBase / VROInputPresenter, which are oriented at
+ pointer/click events for raycasting in AR/VR scenes. VROInputState models the
+ "continuous controller snapshot" use case: per-frame stick deflections, button
+ hold states, analog triggers.
+
+ Thread-safety: write methods are safe to call from any thread (touch handler,
+ gamepad callback, sensor thread). Readers call snapshot() to get a consistent
+ view of the entire state in one shot. Internal mutex contention is negligible
+ because each writer touches the state at most a few times per frame.
+
+ Button indices are caller-defined; the table below documents the recommended
+ default mapping for game-style apps. Adapters can map their physical inputs
+ to any index they like.
+ */
+
+class VROInputState {
+
+public:
+
+    static constexpr int kMaxButtons = 32;
+
+    /*
+     Recommended button-index mapping for SM64-style inputs and most casual
+     games. Adapters that target this layout populate buttons at these indices;
+     consumers that read this layout know what each bit means. Mappings are
+     not enforced — they are conventions.
+     */
+    enum DefaultButton : int {
+        Button_A   = 0,   // jump / primary action
+        Button_B   = 1,   // attack / grab / secondary action
+        Button_X   = 2,
+        Button_Y   = 3,
+        Button_Z   = 4,   // crouch / ground-pound
+        Button_L1  = 5,
+        Button_R1  = 6,
+        Button_L2  = 7,
+        Button_R2  = 8,
+        Button_Start  = 9,
+        Button_Select = 10,
+        Button_StickLClick = 11,
+        Button_StickRClick = 12,
+        Button_DPad_Up    = 13,
+        Button_DPad_Down  = 14,
+        Button_DPad_Left  = 15,
+        Button_DPad_Right = 16,
+        // 17..31 free for app-specific buttons
+    };
+
+    /*
+     Plain-data snapshot returned by snapshot() and consumed by readers. Safe
+     to copy and pass across threads.
+     */
+    struct Snapshot {
+        float stickLX = 0.f;
+        float stickLY = 0.f;
+        float stickRX = 0.f;
+        float stickRY = 0.f;
+        float triggerL = 0.f;
+        float triggerR = 0.f;
+        uint32_t buttonBits = 0;   // bit i = button i state (1 = pressed)
+
+        bool getButton(int idx) const {
+            if (idx < 0 || idx >= kMaxButtons) return false;
+            return (buttonBits & (1u << idx)) != 0;
+        }
+    };
+
+    VROInputState() = default;
+
+    /*
+     Reader API. Returns a consistent snapshot of every field. Cheap; takes the
+     mutex once.
+     */
+    Snapshot snapshot() const;
+
+    /*
+     Writer API. Each call takes the mutex briefly. Adapters can call these
+     from any thread.
+
+     Stick axis convention: x in [-1, 1] left-to-right, y in [-1, 1]
+     down-to-up. Adapters are responsible for sign conventions and clamping;
+     values outside [-1, 1] are accepted but consumers may behave oddly.
+     */
+    void setStickL(float x, float y);
+    void setStickR(float x, float y);
+    void setTriggerL(float value);
+    void setTriggerR(float value);
+    void setButton(int idx, bool pressed);
+
+    /*
+     Reset all fields to neutral (sticks zeroed, triggers zeroed, no buttons
+     pressed). Called when a source adapter unregisters or when a controller
+     is intentionally cleared (e.g. on app background).
+     */
+    void reset();
+
+private:
+
+    mutable std::mutex _mtx;
+    Snapshot _state;
+
+};
+
+#endif /* VROInputState_h */

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROMonocularDepthEstimator.h

@@ -82,6 +82,15 @@ public:
  *   estimator->update(arFrame);
  *   auto depthTexture = estimator->getDepthTexture();
  */
+/**
+ * Controls how the monocular depth estimator derives metric scale.
+ */
+enum class VROMonocularDepthCalibration {
+    None,           // no scaling (raw model output, scale = 1.0)
+    Manual,         // caller sets scale via setScaleFactor() (default)
+    LiDARReference, // stub: sample LiDAR to auto-derive scale (falls back to Manual)
+};
+
 class API_AVAILABLE(ios(14.0)) VROMonocularDepthEstimator :
     public std::enable_shared_from_this<VROMonocularDepthEstimator> {
 
@@ -126,6 +135,16 @@ public:
      */
     void update(const VROARFrame *frame);
 
+    /**
+     * Run a single throwaway inference on a blank image to force CoreML / Neural Engine
+     * model specialization up front. Without this, the FIRST real inference pays the
+     * full ANE compile cost (many seconds on A-series chips) — the dominant cause of the
+     * long delay before the first depth frame appears. Safe to call once right after
+     * initWithModel(); runs asynchronously on the depth queue and does not touch the
+     * live depth buffers (it uses a private throwaway request).
+     */
+    void warmup();
+
     #pragma mark - Depth Output
 
     /**
@@ -161,11 +180,28 @@ public:
      * Set the scale factor for converting model output to metric depth.
      * Some models output relative/disparity depth that needs scaling.
      * Default is 1.0 (assumes model outputs metric depth in meters).
+     * Implicitly sets calibration mode to Manual.
      *
      * @param scale The scale factor to multiply depth values by.
      */
     void setScaleFactor(float scale);
 
+    /**
+     * Set the calibration mode that controls how depth scale is derived.
+     * - None: raw model output (scale = 1.0)
+     * - Manual: caller-supplied scale via setScaleFactor() (default)
+     * - LiDARReference: stub, logs warning and falls back to Manual
+     */
+    void setCalibrationMode(VROMonocularDepthCalibration mode);
+    VROMonocularDepthCalibration getCalibrationMode() const;
+
+    /**
+     * Flush any pending depth data to the GPU texture.
+     * Must be called on the render (GL) thread. VROARSessioniOS calls this
+     * automatically each frame before depth is consumed.
+     */
+    void flushPendingDepthUpdate();
+
     /**
      * Enable or disable temporal filtering for depth stability.
      * When enabled, depth values are smoothed across frames using
@@ -232,6 +268,36 @@ public:
      */
     int getDepthBufferHeight() const { return _depthHeight; }
 
+    /**
+     * Atomically snapshot the depth and confidence buffers for offline processing
+     * (e.g. world-mesh generation). Thread-safe — takes a copy under the depth mutex.
+     * Returns false if no data is available.
+     */
+    bool snapshotDepthBuffers(std::vector<float> &outDepth,
+                              std::vector<float> &outConfidence,
+                              int &outWidth, int &outHeight) const;
+
+    /**
+     * Sample the synthesized per-pixel confidence at depth-texture UV coordinates.
+     * Returns a value in [0, 1]: 1 = highly stable, 0 = discontinuity or invalid.
+     * Returns -1 if no confidence data is available (temporal filtering disabled or
+     * first frame). Thread-safe.
+     *
+     * @param u Depth texture U coordinate [0, 1].
+     * @param v Depth texture V coordinate [0, 1].
+     */
+    float sampleConfidenceAtDepthUV(float u, float v) const;
+
+    /**
+     * Set the confidence threshold for hit-test upgrade decisions on the monocular path.
+     * Hit results are upgraded to DepthPoint only when synthesized confidence exceeds
+     * this value. Default is 0.3.
+     *
+     * @param threshold Confidence threshold in [0, 1].
+     */
+    void setHitTestConfidenceThreshold(float threshold);
+    float getHitTestConfidenceThreshold() const;
+
 private:
     // Graphics driver
     std::weak_ptr<VRODriver> _driver;
@@ -258,17 +324,24 @@ private:
     std::shared_ptr<VROTexture> _currentDepthTexture;
     std::vector<float> _depthBuffer;
     std::vector<float> _previousDepthBuffer;
+    std::vector<float> _confidenceBuffer;  // per-pixel synthesized confidence [0,1]
     int _depthWidth;
     int _depthHeight;
     VROMatrix4f _depthTextureTransform;
 
     // Configuration
     float _depthScaleFactor;
+    VROMonocularDepthCalibration _calibrationMode;
+    float _hitTestConfidenceThreshold;
     bool _temporalFilteringEnabled;
     float _temporalFilterAlpha;
     int _targetFPS;
     double _lastInferenceTime;
 
+    // W4: staging buffer for in-place GPU texture updates
+    std::vector<float> _stagingDepthBuffer;
+    std::atomic<bool> _stagingDirty;
+
     // Diagnostics
     float _currentFPS;
     float _averageLatencyMs;

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROObjectDetector.h

@@ -0,0 +1,134 @@
+//
+//  VROObjectDetector.h
+//  ViroRenderer
+//
+//  Copyright © 2026 ReactVision. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef VROObjectDetector_h
+#define VROObjectDetector_h
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <memory>
+
+/*
+ Bounding box in normalized image space [0, 1].
+ Origin is top-left corner of the image.
+ */
+struct VRODetectionBoundingBox {
+    float x;       // left edge
+    float y;       // top edge
+    float width;
+    float height;
+};
+
+struct VRODetectedObject {
+    std::string label;
+    float confidence;
+    VRODetectionBoundingBox boundingBox;
+};
+
+/*
+ Inference mode matching YOLOE's three prompting strategies:
+ - PromptFree: LRPC head, 4,585 built-in RAM++ categories, no runtime prompt needed.
+ - Text:       RepRTA, detect arbitrary categories given a list of text labels.
+ - Visual:     SAVPE, detect objects similar to a reference image crop.
+ */
+enum class VRODetectorMode {
+    PromptFree,
+    Text,
+    Visual,
+};
+
+using VRODetectionCallback = std::function<void(const std::vector<VRODetectedObject> &)>;
+
+/*
+ Abstract base class for on-device object detectors.
+
+ Platform implementations (iOS: CoreML / ONNX Runtime, Android: ONNX Runtime)
+ subclass this and implement loadModel() and detectInBuffer(). The bridge layer
+ owns the camera pipeline and calls detectInBuffer() on each sampled frame.
+ */
+class VROObjectDetector {
+public:
+    virtual ~VROObjectDetector() {}
+
+    /*
+     Load the model from the given path.
+     On iOS:     path to a .mlpackage (CoreML) or .onnx file.
+     On Android: path to a .onnx file inside the app's assets or files dir.
+     Returns true on success.
+     */
+    virtual bool loadModel(const std::string &modelPath) = 0;
+
+    /*
+     Run detection on a raw RGB pixel buffer.
+     - pixels:  pointer to contiguous RGB888 data (row-major)
+     - width / height: image dimensions in pixels
+     Results are delivered asynchronously via the detection callback.
+     */
+    virtual void detectInBuffer(const uint8_t *pixels, int width, int height) = 0;
+
+    // --- configuration (call before loadModel or between frames) ---
+
+    void setMode(VRODetectorMode mode) {
+        _mode = mode;
+    }
+
+    /*
+     Text categories for Text mode (e.g. {"chair", "person", "laptop"}).
+     Ignored in PromptFree and Visual modes.
+     */
+    void setCategories(const std::vector<std::string> &categories) {
+        _categories = categories;
+    }
+
+    void setConfidenceThreshold(float threshold) {
+        _confidenceThreshold = threshold;
+    }
+
+    /*
+     NMS IoU threshold used during post-processing.
+     */
+    void setIouThreshold(float threshold) {
+        _iouThreshold = threshold;
+    }
+
+    void setCallback(VRODetectionCallback callback) {
+        _callback = callback;
+    }
+
+    VRODetectorMode getMode() const { return _mode; }
+    float getConfidenceThreshold() const { return _confidenceThreshold; }
+    float getIouThreshold() const { return _iouThreshold; }
+    const std::vector<std::string> &getCategories() const { return _categories; }
+
+protected:
+    VRODetectorMode _mode = VRODetectorMode::PromptFree;
+    std::vector<std::string> _categories;
+    float _confidenceThreshold = 0.4f;
+    float _iouThreshold = 0.45f;
+    VRODetectionCallback _callback;
+};
+
+#endif /* VROObjectDetector_h */

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROPCMRingBuffer.h

@@ -0,0 +1,143 @@
+//
+//  VROPCMRingBuffer.h
+//  ViroRenderer
+//
+//  Copyright © 2026 ReactVision. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+
+#ifndef VROPCMRingBuffer_h
+#define VROPCMRingBuffer_h
+
+#include <vector>
+#include <atomic>
+#include <algorithm>
+#include <cstring>
+
+/*
+ Lock-free single-producer / single-consumer ring buffer for interleaved float PCM
+ samples. Designed for the streaming audio path:
+
+   Producer (any thread): calls write() with chunks of samples from the
+     simulation / TTS / synthesiser.
+
+   Consumer (audio callback, real-time thread): calls read() to fill the OS
+     audio buffer. Must never block — silence (zeros) is returned when the
+     ring is empty.
+
+ Capacity is set at construction and is a power of two so that the index wrap
+ is a bitwise AND rather than a modulo. A capacity of 8192 samples at 32 kHz
+ stereo gives ~128 ms of headroom, sufficient to absorb a typical JS bridge
+ round-trip.
+
+ NOT safe for multiple producers or multiple consumers.
+*/
+class VROPCMRingBuffer {
+
+public:
+
+    explicit VROPCMRingBuffer(size_t capacitySamples = 8192)
+        : _capacity(nextPow2(capacitySamples)),
+          _mask(_capacity - 1),
+          _buffer(_capacity, 0.0f),
+          _writePos(0),
+          _readPos(0) {}
+
+    /*
+     Write interleaved PCM samples. Called from the producer thread.
+     Returns the number of samples actually written (may be less than count
+     if the ring is nearly full — caller should retry or drop).
+    */
+    size_t write(const float *data, size_t count) {
+        size_t w = _writePos.load(std::memory_order_relaxed);
+        size_t r = _readPos.load(std::memory_order_acquire);
+        size_t available = _capacity - (w - r);   // free slots
+        size_t toWrite   = std::min(count, available);
+        if (toWrite == 0) return 0;
+
+        size_t idx = w & _mask;
+        size_t firstPart = std::min(toWrite, _capacity - idx);
+        memcpy(_buffer.data() + idx, data, firstPart * sizeof(float));
+        if (toWrite > firstPart) {
+            memcpy(_buffer.data(), data + firstPart,
+                   (toWrite - firstPart) * sizeof(float));
+        }
+        _writePos.store(w + toWrite, std::memory_order_release);
+        return toWrite;
+    }
+
+    /*
+     Read interleaved PCM samples into out. Called from the audio callback
+     (consumer thread). Fills with silence if fewer samples are available
+     than requested. Returns number of valid samples read.
+    */
+    size_t read(float *out, size_t count) {
+        size_t r = _readPos.load(std::memory_order_relaxed);
+        size_t w = _writePos.load(std::memory_order_acquire);
+        size_t available = w - r;
+        size_t toRead    = std::min(count, available);
+
+        if (toRead > 0) {
+            size_t idx = r & _mask;
+            size_t firstPart = std::min(toRead, _capacity - idx);
+            memcpy(out, _buffer.data() + idx, firstPart * sizeof(float));
+            if (toRead > firstPart) {
+                memcpy(out + firstPart, _buffer.data(),
+                       (toRead - firstPart) * sizeof(float));
+            }
+            _readPos.store(r + toRead, std::memory_order_release);
+        }
+
+        // Zero-fill any unfulfilled frames (silence on underrun).
+        if (toRead < count) {
+            memset(out + toRead, 0, (count - toRead) * sizeof(float));
+        }
+        return toRead;
+    }
+
+    int sampleRate() const { return _sampleRate; }
+    int channels()   const { return _channels;   }
+
+    void setSampleRate(int sr) { _sampleRate = sr; }
+    void setChannels(int ch)   { _channels   = ch; }
+
+    size_t capacity() const { return _capacity; }
+
+    /*
+     Approximate number of samples currently buffered. Informational only —
+     may be slightly stale by the time the caller acts on it.
+    */
+    size_t available() const {
+        return _writePos.load(std::memory_order_relaxed) -
+               _readPos.load(std::memory_order_relaxed);
+    }
+
+private:
+
+    static size_t nextPow2(size_t n) {
+        size_t p = 1;
+        while (p < n) p <<= 1;
+        return p;
+    }
+
+    const size_t _capacity;
+    const size_t _mask;
+    std::vector<float> _buffer;
+
+    std::atomic<size_t> _writePos;
+    std::atomic<size_t> _readPos;
+
+    int _sampleRate = 44100;
+    int _channels   = 1;
+};
+
+#endif /* VROPCMRingBuffer_h */

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VROPencil.h

@@ -72,9 +72,18 @@ public:
         _brushThickness = thickness;
     }
 
+    /*
+     When enabled, lines are depth-tested against the scene (occluded by closer surfaces).
+     Default false to preserve the original overlay behavior.
+     */
+    void setDepthTestEnabled(bool enabled) {
+        _depthTestEnabled = enabled;
+    }
+
 private:
     std::vector<std::vector<VROVector3f>> _paths;
     float _brushThickness;
+    bool _depthTestEnabled = false;
 };
 
 #endif

package/ios/dist/ViroRenderer/ViroKit.framework/Headers/VRORenderContext.h

@@ -208,6 +208,9 @@ public:
         return _depthTexture;
     }
 
+    void setDepthIsMonocular(bool monocular) { _depthIsMonocular = monocular; }
+    bool isDepthMonocular() const { return _depthIsMonocular; }
+
     void setSceneDepthTexture(std::shared_ptr<VROTexture> texture) {
         _sceneDepthTexture = texture;
     }
@@ -358,6 +361,7 @@ private:
      Depth texture from AR framework for occlusion.
      */
     std::shared_ptr<VROTexture> _depthTexture;
+    bool _depthIsMonocular = false;
 
     /*
      Scene depth texture captured from the previous frame's base render pass.