@reactvision/react-viro 2.44.0 → 2.44.2

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

@@ -0,0 +1,124 @@
+//
+//  VROVector2f.h
+//  ViroRenderer
+//
+//  Copyright © 2025 Viro Media. 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 VROVECTOR2F_H_
+#define VROVECTOR2F_H_
+
+#include <stdlib.h>
+#include <math.h>
+#include <string>
+
+class VROVector2f {
+public:
+    float x;
+    float y;
+
+    VROVector2f() noexcept : x(0), y(0) {}
+    VROVector2f(float x, float y) : x(x), y(y) {}
+
+    VROVector2f &operator*=(const float multiplier) {
+        x *= multiplier;
+        y *= multiplier;
+        return *this;
+    }
+
+    VROVector2f &operator/=(const float divisor) {
+        x /= divisor;
+        y /= divisor;
+        return *this;
+    }
+
+    VROVector2f &operator+=(const VROVector2f &rhs) {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    VROVector2f &operator-=(const VROVector2f &rhs) {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    VROVector2f operator+(const VROVector2f &vec) const {
+        VROVector2f result = *this;
+        result += vec;
+        return result;
+    }
+
+    VROVector2f operator-(const VROVector2f &vec) const {
+        VROVector2f result = *this;
+        result -= vec;
+        return result;
+    }
+
+    VROVector2f operator*(const float multiplier) const {
+        VROVector2f result = *this;
+        result *= multiplier;
+        return result;
+    }
+
+    VROVector2f operator/(const float divisor) const {
+        VROVector2f result = *this;
+        result /= divisor;
+        return result;
+    }
+
+    bool operator==(const VROVector2f &rhs) const {
+        return x == rhs.x && y == rhs.y;
+    }
+
+    bool operator!=(const VROVector2f &rhs) const {
+        return !(*this == rhs);
+    }
+
+    float magnitude() const {
+        return sqrtf(x * x + y * y);
+    }
+
+    float distance(const VROVector2f &to) const {
+        float dx = to.x - x;
+        float dy = to.y - y;
+        return sqrtf(dx * dx + dy * dy);
+    }
+
+    VROVector2f normalize() const {
+        float mag = magnitude();
+        if (mag > 0) {
+            return VROVector2f(x / mag, y / mag);
+        }
+        return VROVector2f(0, 0);
+    }
+
+    float dot(const VROVector2f &rhs) const {
+        return x * rhs.x + y * rhs.y;
+    }
+
+    std::string toString() const {
+        return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
+    }
+};
+
+#endif /* VROVECTOR2F_H_ */

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROARDeclarativeNode.h

@@ -101,7 +101,7 @@ public:
             delegate->onARAnchorAttached(getAnchor());
         }
     }
-    
+
     virtual void onARAnchorUpdated() {
         std::shared_ptr<VROARDeclarativeNodeDelegate> delegate = getARNodeDelegate();
         if (delegate) {

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROARDeclarativePlane.h

@@ -46,14 +46,31 @@ public:
     
     /*
      Returns whether or not the given VROARAnchor fulfills this plane's requirements.
+
+     NOTE: This uses hysteresis for CONSTRAINT MATCHING only - it doesn't affect the
+     precision of plane data from ARCore/ARKit. Hysteresis prevents nodes from rapidly
+     attaching/detaching when plane dimensions fluctuate near the app's minimum requirements.
+
+     This is application-level logic and does not filter or modify ARCore/ARKit plane data.
      */
     bool hasRequirementsFulfilled(std::shared_ptr<VROARAnchor> candidate) {
         std::shared_ptr<VROARPlaneAnchor> planeAnchor = std::dynamic_pointer_cast<VROARPlaneAnchor>(candidate->getAnchorForTrackable());
         if (!planeAnchor) {
             return false;
         }
-        
-        if (planeAnchor->getExtent().x < _minWidth || planeAnchor->getExtent().z < _minHeight) {
+
+        // Apply hysteresis: if the plane is already attached to this anchor,
+        // allow it to be 10% smaller before detaching. This prevents flickering
+        // when plane dimensions fluctuate near the application's size threshold.
+        // This does NOT affect the precision of the plane data itself.
+        bool isCurrentlyAttached = (getAnchor() == candidate);
+        float hysteresisMargin = isCurrentlyAttached ? 0.90f : 1.0f;
+
+        float effectiveMinWidth = _minWidth * hysteresisMargin;
+        float effectiveMinHeight = _minHeight * hysteresisMargin;
+
+        if (planeAnchor->getExtent().x < effectiveMinWidth ||
+            planeAnchor->getExtent().z < effectiveMinHeight) {
             return false;
         }
 
@@ -98,10 +115,12 @@ public:
                     && _alignment != VROARPlaneAlignment::HorizontalDownward) {
                     return false;
                 }
+                break;
             case VROARPlaneAlignment::Vertical:
                 if (_alignment != VROARPlaneAlignment::Vertical) {
                     return false;
                 }
+                break;
             default:
                 break;
         }

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROARPlaneAnchor.h

@@ -29,6 +29,20 @@
 
 #include "VROARAnchor.h"
 #include "VROVector3f.h"
+#include "VROVector2f.h"
+#include <chrono>
+
+/*
+ ENABLED: Change detection and update throttling to reduce noise and artifacts.
+ This filters out small plane changes and prevents excessive updates, which is
+ particularly important for vertical plane detection where ARCore can be noisy.
+
+ Thresholds:
+ - Minimum extent change: 1cm or 5%
+ - Minimum center change: 1cm
+ - Update throttle: 100ms (10 updates/sec max)
+ */
+#define VRO_PLANE_CHANGE_DETECTION_ENABLED
 
 enum class VROARPlaneAlignment {
     Horizontal = 0x1,
@@ -37,14 +51,33 @@ enum class VROARPlaneAlignment {
     Vertical = 0x10,
 };
 
+/*
+ Classification of detected planes (iOS 12+, ARCore semantic labels).
+ Indicates the semantic meaning of a detected plane.
+ */
+enum class VROARPlaneClassification {
+    None,
+    Wall,
+    Floor,
+    Ceiling,
+    Table,
+    Seat,
+    Door,
+    Window,
+    Unknown
+};
+
 /*
  Anchor representing a planar surface.
  */
 class VROARPlaneAnchor : public VROARAnchor {
-    
+
 public:
-    
-    VROARPlaneAnchor() {}
+
+    VROARPlaneAnchor() :
+        _lastUpdateTime(std::chrono::steady_clock::now()),
+        _updateCount(0),
+        _significantChangeCount(0) {}
     virtual ~VROARPlaneAnchor() {}
     
     /*
@@ -85,7 +118,140 @@ public:
     std::vector<VROVector3f> getBoundaryVertices() {
         return  _boundaryVertices;
     }
-    
+
+    /*
+     Full mesh geometry (iOS 11.3+ only - ARSCNPlaneGeometry equivalent).
+     Provides detailed tessellated surface representation beyond just boundary.
+     On Android/ARCore, these will be empty as ARCore only provides boundaries.
+     */
+    void setMeshVertices(std::vector<VROVector3f> vertices) {
+        _meshVertices = std::move(vertices);
+    }
+    std::vector<VROVector3f> getMeshVertices() const {
+        return _meshVertices;
+    }
+
+    void setTextureCoordinates(std::vector<VROVector2f> uvs) {
+        _textureCoordinates = std::move(uvs);
+    }
+    std::vector<VROVector2f> getTextureCoordinates() const {
+        return _textureCoordinates;
+    }
+
+    void setTriangleIndices(std::vector<int> indices) {
+        _triangleIndices = std::move(indices);
+    }
+    std::vector<int> getTriangleIndices() const {
+        return _triangleIndices;
+    }
+
+    /*
+     Plane classification (iOS 12+, ARCore semantic labels).
+     Indicates what type of surface this plane represents.
+     */
+    void setClassification(VROARPlaneClassification classification) {
+        _classification = classification;
+    }
+    VROARPlaneClassification getClassification() const {
+        return _classification;
+    }
+
+    /*
+     Change detection and throttling for plane updates.
+     */
+
+    // Check if plane properties have changed significantly
+    bool hasSignificantChanges(VROVector3f newCenter, VROVector3f newExtent,
+                               VROARPlaneAlignment newAlignment,
+                               const std::vector<VROVector3f> &newBoundaryVertices) const {
+        // Thresholds for detecting significant changes
+        static const float EXTENT_THRESHOLD = 0.01f;      // 1cm change in dimensions
+        static const float CENTER_THRESHOLD = 0.01f;      // 1cm change in center
+        static const float EXTENT_PERCENT_THRESHOLD = 0.05f; // 5% change in size
+
+        // Check alignment change
+        if (newAlignment != _alignment) {
+            return true;
+        }
+
+        // Check extent change (absolute and percentage)
+        VROVector3f extentDiff = newExtent - _extent;
+        float maxExtentDiff = std::max(std::abs(extentDiff.x), std::abs(extentDiff.z));
+        if (maxExtentDiff > EXTENT_THRESHOLD) {
+            // Also check percentage change for larger planes
+            if (_extent.magnitude() > 0.001f) {
+                float percentChange = maxExtentDiff / _extent.magnitude();
+                if (percentChange > EXTENT_PERCENT_THRESHOLD) {
+                    return true;
+                }
+            } else {
+                // For very small planes, any change is significant
+                return true;
+            }
+        }
+
+        // Check center change
+        VROVector3f centerDiff = newCenter - _center;
+        if (centerDiff.magnitude() > CENTER_THRESHOLD) {
+            return true;
+        }
+
+        // Check boundary vertices count change
+        if (newBoundaryVertices.size() != _boundaryVertices.size()) {
+            return true;
+        }
+
+        // Check boundary vertices significant changes (sample-based for performance)
+        if (!newBoundaryVertices.empty() && !_boundaryVertices.empty()) {
+            // Sample a few vertices instead of checking all for performance
+            size_t sampleCount = std::min(size_t(4), newBoundaryVertices.size());
+            size_t step = newBoundaryVertices.size() / sampleCount;
+            if (step < 1) step = 1;
+
+            for (size_t i = 0; i < newBoundaryVertices.size(); i += step) {
+                VROVector3f diff = newBoundaryVertices[i] - _boundaryVertices[i];
+                if (diff.magnitude() > CENTER_THRESHOLD) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    // Check if update should be throttled
+    bool shouldThrottleUpdate() const {
+        // Minimum time between updates (milliseconds)
+        static const int MIN_UPDATE_INTERVAL_MS = 100; // 10 updates per second max
+
+        auto now = std::chrono::steady_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - _lastUpdateTime).count();
+
+        return elapsed < MIN_UPDATE_INTERVAL_MS;
+    }
+
+    // Mark that an update occurred
+    void recordUpdate(bool wasSignificant) {
+        _lastUpdateTime = std::chrono::steady_clock::now();
+        _updateCount++;
+        if (wasSignificant) {
+            _significantChangeCount++;
+        }
+    }
+
+    // Get update statistics for diagnostics
+    uint32_t getUpdateCount() const { return _updateCount; }
+    uint32_t getSignificantChangeCount() const { return _significantChangeCount; }
+    float getSignificantChangeRatio() const {
+        return _updateCount > 0 ? (float)_significantChangeCount / _updateCount : 0.0f;
+    }
+
+    // Get time since last update (milliseconds) - useful for debugging update frequency
+    int64_t getTimeSinceLastUpdate() const {
+        auto now = std::chrono::steady_clock::now();
+        return std::chrono::duration_cast<std::chrono::milliseconds>(now - _lastUpdateTime).count();
+    }
+
 private:
     
     /*
@@ -108,6 +274,27 @@ private:
      A vector of points representing the vertex boundaries of this plane, if any.
      */
     std::vector<VROVector3f> _boundaryVertices;
+
+    /*
+     Full mesh geometry (iOS 11.3+ only).
+     Detailed tessellated mesh from ARSCNPlaneGeometry.
+     Empty on Android as ARCore only provides boundary polygon.
+     */
+    std::vector<VROVector3f> _meshVertices;
+    std::vector<VROVector2f> _textureCoordinates;
+    std::vector<int> _triangleIndices;
+
+    /*
+     Plane classification (iOS 12+, ARCore semantic labels).
+     */
+    VROARPlaneClassification _classification = VROARPlaneClassification::None;
+
+    /*
+     Update tracking and throttling.
+     */
+    std::chrono::steady_clock::time_point _lastUpdateTime;
+    uint32_t _updateCount;
+    uint32_t _significantChangeCount;
 };
 
 #endif /* VROARPlaneAnchor_h */

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROVector2f.h

@@ -0,0 +1,124 @@
+//
+//  VROVector2f.h
+//  ViroRenderer
+//
+//  Copyright © 2025 Viro Media. 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 VROVECTOR2F_H_
+#define VROVECTOR2F_H_
+
+#include <stdlib.h>
+#include <math.h>
+#include <string>
+
+class VROVector2f {
+public:
+    float x;
+    float y;
+
+    VROVector2f() noexcept : x(0), y(0) {}
+    VROVector2f(float x, float y) : x(x), y(y) {}
+
+    VROVector2f &operator*=(const float multiplier) {
+        x *= multiplier;
+        y *= multiplier;
+        return *this;
+    }
+
+    VROVector2f &operator/=(const float divisor) {
+        x /= divisor;
+        y /= divisor;
+        return *this;
+    }
+
+    VROVector2f &operator+=(const VROVector2f &rhs) {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    VROVector2f &operator-=(const VROVector2f &rhs) {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    VROVector2f operator+(const VROVector2f &vec) const {
+        VROVector2f result = *this;
+        result += vec;
+        return result;
+    }
+
+    VROVector2f operator-(const VROVector2f &vec) const {
+        VROVector2f result = *this;
+        result -= vec;
+        return result;
+    }
+
+    VROVector2f operator*(const float multiplier) const {
+        VROVector2f result = *this;
+        result *= multiplier;
+        return result;
+    }
+
+    VROVector2f operator/(const float divisor) const {
+        VROVector2f result = *this;
+        result /= divisor;
+        return result;
+    }
+
+    bool operator==(const VROVector2f &rhs) const {
+        return x == rhs.x && y == rhs.y;
+    }
+
+    bool operator!=(const VROVector2f &rhs) const {
+        return !(*this == rhs);
+    }
+
+    float magnitude() const {
+        return sqrtf(x * x + y * y);
+    }
+
+    float distance(const VROVector2f &to) const {
+        float dx = to.x - x;
+        float dy = to.y - y;
+        return sqrtf(dx * dx + dy * dy);
+    }
+
+    VROVector2f normalize() const {
+        float mag = magnitude();
+        if (mag > 0) {
+            return VROVector2f(x / mag, y / mag);
+        }
+        return VROVector2f(0, 0);
+    }
+
+    float dot(const VROVector2f &rhs) const {
+        return x * rhs.x + y * rhs.y;
+    }
+
+    std::string toString() const {
+        return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
+    }
+};
+
+#endif /* VROVECTOR2F_H_ */

package/package.json

@@ -3,7 +3,7 @@
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "version": "2.44.0",
+  "version": "2.44.2",
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -88,6 +88,6 @@
   "bugs": {
     "url": "https://github.com/ReactVision/viro/issues"
   },
-  "homepage": "https://github.com/ReactVision/viro#readme",
-  "author": ""
+  "homepage": "https://reactvision.xyz/viro-react",
+  "author": "ReactVision, Inc"
 }