@reactvision/react-viro 2.44.0 → 2.44.2

package/dist/components/AR/ViroARPlaneSelector.js

@@ -48,8 +48,8 @@ const React = __importStar(require("react"));
 const ViroMaterials_1 = require("../Material/ViroMaterials");
 const ViroNode_1 = require("../ViroNode");
 const ViroQuad_1 = require("../ViroQuad");
+const ViroPolygon_1 = require("../ViroPolygon");
 const ViroARPlane_1 = require("./ViroARPlane");
-var _maxPlanes = 15;
 var _planePrefix = "ViroARPlaneSelector_Plane_";
 /**
  * This component wraps the logic required to enable user selection
@@ -59,9 +59,8 @@ var _planePrefix = "ViroARPlaneSelector_Plane_";
 class ViroARPlaneSelector extends React.Component {
     _component = null;
     state = {
-        selectedSurface: -1,
-        foundARPlanes: [],
-        arPlaneSizes: [],
+        selectedPlaneId: null,
+        foundARPlanes: new Map(),
     };
     render() {
         // Uncomment this line to check for misnamed props
@@ -69,78 +68,151 @@ class ViroARPlaneSelector extends React.Component {
         return <ViroNode_1.ViroNode>{this._getARPlanes()}</ViroNode_1.ViroNode>;
     }
     _getARPlanes() {
-        // Always render a fixed number of planes, controlling visibility instead of conditional rendering
-        let arPlanes = [];
-        let numPlanes = this.props.maxPlanes || _maxPlanes;
-        // Create all plane slots (both detected and placeholder)
-        for (let i = 0; i < numPlanes; i++) {
-            // Determine if this is the selected plane
-            const isSelected = this.state.selectedSurface === i;
-            // Get real plane data if available, or use defaults
-            const foundARPlane = this.state.foundARPlanes[i];
-            const hasPlaneData = !!foundARPlane;
-            // Extract plane data or use defaults
-            const surfaceWidth = hasPlaneData ? foundARPlane.width || 0.5 : 0.5;
-            const surfaceHeight = hasPlaneData ? foundARPlane.height || 0.5 : 0.5;
-            const surfacePosition = hasPlaneData
-                ? foundARPlane.center || [0, 0, 0]
-                : [0, 0, 0];
-            const anchorId = hasPlaneData
-                ? foundARPlane.anchorId
-                : undefined;
-            // Determine visibility based on selection state
-            // - In selection mode (selectedSurface === -1): show all planes
-            // - In selected mode: only show the selected plane
-            const isVisible = this.state.selectedSurface === -1 || isSelected;
-            arPlanes.push(<ViroARPlane_1.ViroARPlane key={_planePrefix + i} minWidth={this.props.minWidth || 0.5} minHeight={this.props.minHeight || 0.5} alignment={this.props.alignment} anchorId={anchorId} onAnchorFound={(anchor) => {
-                    // If we find an anchor, update our plane data
-                    this._onARPlaneUpdated(i)(anchor);
-                }} onAnchorUpdated={this._onARPlaneUpdated(i)}>
-          {/* Always render both the quad and children, controlling only visibility */}
-          <ViroQuad_1.ViroQuad materials={"ViroARPlaneSelector_Translucent"} onClickState={(clickState, position, source) => this._getOnClickSurface(i, { clickState, position, source })} position={surfacePosition} width={surfaceWidth} height={surfaceHeight} rotation={[-90, 0, 0]} opacity={isSelected ? 0 : isVisible ? 1 : 0}/>
-
-          {/* Wrap children in a ViroNode to control visibility if children exist */}
-          {this.props.children && (<ViroNode_1.ViroNode opacity={isSelected ? 1 : 0}>
-              {this.props.children}
-            </ViroNode_1.ViroNode>)}
-        </ViroARPlane_1.ViroARPlane>);
+        const arPlanes = [];
+        const detectBothAlignments = this.props.alignment === "Both" || !this.props.alignment;
+        // Determine which alignments to detect
+        const alignmentsToDetect = [];
+        if (detectBothAlignments) {
+            alignmentsToDetect.push("Horizontal", "Vertical");
         }
+        else if (this.props.alignment) {
+            // Type assertion safe here because we know it's not "Both" due to detectBothAlignments check
+            alignmentsToDetect.push(this.props.alignment);
+        }
+        // Create detector ViroARPlane components for each alignment type
+        // These don't have anchorId set initially, but will discover and track planes
+        // We add visual children based on detected plane data
+        const detectorsPerAlignment = 25; // 25 detectors per alignment type
+        alignmentsToDetect.forEach((alignment) => {
+            for (let i = 0; i < detectorsPerAlignment; i++) {
+                const detectorKey = `${_planePrefix}detector_${alignment}_${i}`;
+                // Check if this detector has discovered a plane
+                // We'll match by checking if any plane in foundARPlanes has this alignment
+                // and hasn't been assigned to a previous detector
+                // Note: ARCore returns "HorizontalUpward", "HorizontalDownward", etc.
+                // so we need to check if alignment starts with the requested type
+                const detectedPlanes = Array.from(this.state.foundARPlanes.entries()).filter(([_id, plane]) => {
+                    if (alignment === "Horizontal") {
+                        return plane.alignment.includes("Horizontal");
+                    }
+                    else if (alignment === "Vertical") {
+                        return plane.alignment.includes("Vertical");
+                    }
+                    return plane.alignment === alignment;
+                });
+                const planeData = detectedPlanes[i]?.[1];
+                const anchorId = detectedPlanes[i]?.[0];
+                const hasPlaneData = !!planeData;
+                // Extract visual rendering data if plane detected
+                let visualElement = null;
+                if (hasPlaneData) {
+                    const isSelected = this.state.selectedPlaneId === anchorId;
+                    const surfaceWidth = planeData.width || 0.5;
+                    const surfaceHeight = planeData.height || 0.5;
+                    const vertices3D = planeData.vertices;
+                    // Convert 3D vertices to 2D based on plane alignment
+                    // ViroARPlane provides vertices in the plane's LOCAL coordinate system
+                    // where the plane is always in the XZ plane. The anchor handles world orientation.
+                    // Always extract [x, z] since vertices are in the plane's local XZ plane
+                    const vertices2D = vertices3D && vertices3D.length >= 3
+                        ? vertices3D.map(([x, _y, z]) => [
+                            x,
+                            z,
+                        ])
+                        : undefined;
+                    // Rotation for ViroPolygon:
+                    // ViroPolygon renders in XY plane by default, vertices are provided in XZ
+                    // Need to rotate to map XZ plane to XY rendering plane
+                    const polygonRotation = [-90, 0, 0];
+                    const isVisible = this.state.selectedPlaneId === null || isSelected;
+                    // Use actual plane shapes (ViroPolygon with vertices)
+                    const forceQuadForAndroid = false; // Now using actual shapes on Android
+                    const useActualShape = !forceQuadForAndroid &&
+                        this.props.useActualShape !== false &&
+                        vertices2D &&
+                        vertices2D.length >= 3;
+                    const finalOpacity = isSelected ? 0 : isVisible ? 1 : 0;
+                    visualElement = useActualShape ? (<ViroPolygon_1.ViroPolygon key={`polygon-${anchorId}`} vertices={vertices2D} holes={[]} materials={["ViroARPlaneSelector_Translucent"]} {...(!this.props.disableClickSelection && {
+                        onClickState: (clickState, position, source) => this._getOnClickSurface(anchorId, {
+                            clickState,
+                            position,
+                            source,
+                        }),
+                    })} position={[0, 0, 0]} rotation={polygonRotation} opacity={finalOpacity}/>) : (<ViroQuad_1.ViroQuad key={`quad-${anchorId}`} materials={["ViroARPlaneSelector_Translucent"]} {...(!this.props.disableClickSelection && {
+                        onClickState: (clickState, position, source) => this._getOnClickSurface(anchorId, {
+                            clickState,
+                            position,
+                            source,
+                        }),
+                    })} position={[0, 0, 0]} width={surfaceWidth} height={surfaceHeight} rotation={polygonRotation} opacity={finalOpacity}/>);
+                }
+                arPlanes.push(<ViroARPlane_1.ViroARPlane key={detectorKey} minWidth={this.props.minWidth || 0} minHeight={this.props.minHeight || 0} alignment={alignment} anchorId={hasPlaneData ? anchorId : undefined} onAnchorFound={(anchor) => {
+                        this._onARPlaneUpdated(anchor);
+                    }} onAnchorUpdated={(anchor) => {
+                        this._onARPlaneUpdated(anchor);
+                    }}>
+            {visualElement}
+            {hasPlaneData && this.props.children && (<ViroNode_1.ViroNode opacity={this.state.selectedPlaneId === anchorId ? 1 : 0}>
+                {this.props.children}
+              </ViroNode_1.ViroNode>)}
+          </ViroARPlane_1.ViroARPlane>);
+            }
+        });
         return arPlanes;
     }
-    _getOnClickSurface = (index, event) => {
+    _getOnClickSurface = (anchorId, event) => {
         if (event.clickState < 3) {
             return;
         }
         // Get the plane data before updating state to avoid race conditions
-        const selectedPlane = this.state.foundARPlanes[index];
+        const selectedPlane = this.state.foundARPlanes.get(anchorId);
         if (!selectedPlane) {
             console.warn("ViroARPlaneSelector: Cannot select plane - plane data not found");
             return;
         }
         // Update state and call callback with the captured data
-        this.setState({ selectedSurface: index }, () => {
+        this.setState({ selectedPlaneId: anchorId }, () => {
             this._onPlaneSelected(selectedPlane);
         });
     };
-    _onARPlaneUpdated = (index) => {
-        return (updateMap) => {
-            let newPlanes = [...this.state.foundARPlanes];
-            newPlanes[index] = updateMap;
-            this.setState({
-                foundARPlanes: newPlanes,
-                arPlaneSizes: this.state.arPlaneSizes,
-            });
+    _onARPlaneUpdated = (anchor) => {
+        if (!anchor.anchorId) {
+            console.warn("ViroARPlaneSelector: Anchor missing anchorId");
+            return;
+        }
+        const updateMap = {
+            anchorId: anchor.anchorId,
+            type: anchor.type || "plane",
+            position: anchor.position,
+            rotation: anchor.rotation,
+            scale: anchor.scale,
+            center: anchor.center,
+            width: anchor.width,
+            height: anchor.height,
+            alignment: anchor.alignment,
+            classification: anchor.classification,
+            vertices: anchor.vertices,
         };
+        // Update or add plane in Map
+        this.setState((prevState) => {
+            const newPlanes = new Map(prevState.foundARPlanes);
+            newPlanes.set(anchor.anchorId, updateMap);
+            return { foundARPlanes: newPlanes };
+        });
+        // Call validation callback if provided
+        if (this.props.onPlaneDetected) {
+            this.props.onPlaneDetected(updateMap);
+        }
     };
     _onPlaneSelected = (updateMap) => {
         this.props.onPlaneSelected && this.props.onPlaneSelected(updateMap);
     };
-    /*
-    This function allows the user to reset the surface and select a new plane.
-    */
+    /**
+     * This function allows the user to reset the surface and select a new plane.
+     */
     reset = () => {
         this.setState({
-            selectedSurface: -1,
+            selectedPlaneId: null,
         });
     };
 }
@@ -148,6 +220,9 @@ exports.ViroARPlaneSelector = ViroARPlaneSelector;
 ViroMaterials_1.ViroMaterials.createMaterials({
     ViroARPlaneSelector_Translucent: {
         lightingModel: "Constant",
-        diffuseColor: "#88888888",
+        diffuseColor: "rgba(0, 122, 255, 0.5)", // Bright blue with 50% opacity for better visibility
+        blendMode: "Alpha",
+        cullMode: "None", // Render both sides for better Android compatibility
+        writesToDepthBuffer: false,
     },
 });

package/dist/components/Material/ViroMaterials.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViroMaterials = void 0;
 const react_native_1 = require("react-native");
 // @ts-ignore
-const AssetRegistry_1 = __importDefault(require("react-native/Libraries/Image/AssetRegistry"));
+const AssetRegistry_1 = require("react-native/Libraries/Image/AssetRegistry");
 // @ts-ignore
 const resolveAssetSource_1 = __importDefault(require("react-native/Libraries/Image/resolveAssetSource"));
 var MaterialManager = react_native_1.NativeModules.VRTMaterialManager;
@@ -47,7 +47,7 @@ class ViroMaterials {
                     else {
                         var assetType = "unknown";
                         if (typeof material[prop] !== "object") {
-                            var asset = AssetRegistry_1.default.getAssetByID(material[prop]);
+                            var asset = (0, AssetRegistry_1.getAssetByID)(material[prop]);
                             if (asset) {
                                 assetType = asset.type;
                             }

package/dist/components/Types/ViroEvents.d.ts

@@ -167,6 +167,35 @@ export type ViroAnimatedComponentFinishEvent = {};
 /** ===========================================================================
  * Viro AR Anchor Events
  * ============================================================================ */
+/**
+ * Classification of detected planes.
+ * iOS 12+ provides ML-based classification via ARKit.
+ * Android provides basic inference from plane orientation.
+ */
+export type ViroARPlaneClassification = "None" | "Wall" | "Floor" | "Ceiling" | "Table" | "Seat" | "Door" | "Window" | "Unknown";
+/**
+ * Alignment of detected planes with respect to gravity.
+ */
+export type ViroARPlaneAlignment = "Horizontal" | "HorizontalUpward" | "HorizontalDownward" | "Vertical";
+/**
+ * Represents an AR anchor detected in the real world.
+ */
+export type ViroAnchor = {
+    anchorId: string;
+    type: "anchor" | "plane" | "image";
+    position: [number, number, number];
+    rotation: [number, number, number];
+    scale: [number, number, number];
+    center?: [number, number, number];
+    width?: number;
+    height?: number;
+    alignment?: ViroARPlaneAlignment;
+    classification?: ViroARPlaneClassification;
+    vertices?: Array<[number, number, number]>;
+    trackingMethod?: string;
+};
+export type ViroAnchorFoundMap = ViroAnchor;
+export type ViroAnchorUpdatedMap = ViroAnchor;
 export type ViroARAnchorRemovedEvent = {
     anchor: ViroAnchor;
 };
@@ -178,13 +207,10 @@ export type ViroARAnchorFoundEvent = {
     anchorFoundMap: ViroAnchorFoundMap;
     anchor: ViroAnchor;
 };
-export type ViroAnchor = any;
-export type ViroAnchorFoundMap = any;
-export type ViroAnchorUpdatedMap = any;
 /** ===========================================================================
  * Viro AR Plane Events
  * ============================================================================ */
-export type ViroPlaneUpdatedMap = any;
+export type ViroPlaneUpdatedMap = ViroAnchor;
 export type ViroPlaneUpdatedEvent = any;
 export type ViroARPlaneSizes = any;
 /** ===========================================================================

package/dist/components/Utilities/ViroVersion.d.ts

@@ -1 +1 @@
-export declare const VIRO_VERSION = "2.44.0";
+export declare const VIRO_VERSION = "2.44.2";

package/dist/components/Utilities/ViroVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VIRO_VERSION = void 0;
-exports.VIRO_VERSION = "2.44.0";
+exports.VIRO_VERSION = "2.44.2";

package/ios/dist/ViroRenderer/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/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/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 */