@reactvision/react-viro 2.55.0 → 2.57.0

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

@@ -30,6 +30,9 @@
 #include <string>
 #include <chrono>
 #include <functional>
+#include <map>
+#include <mutex>
+#include <cstdint>
 #include "VROVector3f.h"
 
 class VROARDepthMesh;
@@ -50,16 +53,36 @@ struct VROWorldMeshConfig {
     float maxDepth = 5.0f;              // Maximum depth in meters
 
     // Update settings
-    double updateIntervalMs = 100.0;    // Minimum time between mesh updates
+    double updateIntervalMs = 500.0;    // Minimum time between mesh updates
     double meshPersistenceMs = 500.0;   // Time to keep mesh after depth data lost
 
     // Physics properties
     float friction = 0.5f;              // Surface friction coefficient
     float restitution = 0.3f;           // Bounciness (0 = no bounce, 1 = full bounce)
     std::string collisionTag = "world"; // Tag for collision event identification
+    int physicsMaxTriangles = 0;        // Stride-decimation triangle cap (0 = no limit). Leaves
+                                        // large gaps — prefer physicsCellSize for collision.
+    float physicsCellSize = 0.10f;      // Vertex-clustering cell size in meters (0 = disabled).
+                                        // Groups nearby vertices into a single representative,
+                                        // producing a gap-free simplified mesh. Max collision gap =
+                                        // sqrt(3) * cellSize. 0.10m → catches objects >~8cm reliably.
+                                        // Applied before physicsMaxTriangles (if both set).
 
     // Visualization
-    bool debugDrawEnabled = false;      // Enable wireframe visualization of mesh
+    bool debugDrawEnabled = false;         // Enable wireframe visualization of mesh
+    bool debugDrawDepthTest = true;        // Depth-test wireframe against scene (occluded by real surfaces)
+    int debugDrawMaxTriangles = 1000;      // Triangle cap for wireframe debug draw
+    float debugDrawLineThickness = 0.001f; // Line thickness for wireframe (meters)
+};
+
+/**
+ * Identifies the data source that produced a world mesh.
+ */
+enum class VROWorldMeshSource {
+    LiDAR,      // ARKit ARMeshAnchor (LiDAR-equipped device)
+    Monocular,  // Monocular depth estimation (non-LiDAR device)
+    Plane,      // Triangulated AR plane anchors (fallback)
+    Unknown
 };
 
 /**
@@ -74,10 +97,45 @@ struct VROWorldMeshStats {
 };
 
 /**
- * Callback type for mesh update notifications.
+ * Delivered to every registered subscriber when the world mesh is updated.
+ */
+struct VROWorldMeshUpdate {
+    std::shared_ptr<VROARDepthMesh> mesh;
+    VROWorldMeshStats stats;
+    VROWorldMeshSource source = VROWorldMeshSource::Unknown;
+};
+
+/**
+ * Per-subscriber options controlling mesh decimation.
+ * maxTriangles = 0 means no limit (full mesh delivered as-is).
+ */
+struct VROWorldMeshSubscriberOptions {
+    enum class DecimationStrategy {
+        Stride,       // Take every N-th triangle (O(1) per triangle, default)
+    };
+
+    int maxTriangles = 0;                              // 0 = unlimited
+    DecimationStrategy strategy = DecimationStrategy::Stride;
+};
+
+using VROWorldMeshSubscriberId = uint32_t;
+using VROWorldMeshSubscriberCallback = std::function<void(const VROWorldMeshUpdate&)>;
+
+/**
+ * Legacy callback — delivers only stats. Kept for back-compat; prefer subscribe().
  */
 using VROWorldMeshUpdateCallback = std::function<void(const VROWorldMeshStats&)>;
 
+/**
+ * Custom deleter for btRigidBody.
+ * Bullet requires removing the body from the dynamics world before deletion;
+ * this deleter encapsulates that invariant so it can't be forgotten.
+ */
+struct BulletRigidBodyDeleter {
+    std::weak_ptr<VROPhysicsWorld> physicsWorld;
+    void operator()(btRigidBody *body) const;
+};
+
 /**
  * VROARWorldMesh manages the lifecycle of a physics collision mesh generated
  * from AR depth data. It automatically updates the mesh from incoming AR frames
@@ -144,7 +202,21 @@ public:
     VROWorldMeshStats getStats() const;
 
     /**
-     * Set a callback to be notified when the mesh is updated.
+     * Subscribe to mesh updates. Returns an opaque ID used to unsubscribe.
+     * The callback is invoked on the render thread after each successful mesh build.
+     * @param callback Receives the full VROWorldMeshUpdate (mesh, stats, source).
+     * @param options  Per-consumer options (e.g. maxTriangles for W3 decimation).
+     */
+    VROWorldMeshSubscriberId subscribe(VROWorldMeshSubscriberCallback callback,
+                                       VROWorldMeshSubscriberOptions options = {});
+
+    /**
+     * Unsubscribe a previously registered callback. No-op if id is not found.
+     */
+    void unsubscribe(VROWorldMeshSubscriberId id);
+
+    /**
+     * @deprecated Prefer subscribe(). Delivers stats only, no mesh data.
      */
     void setUpdateCallback(VROWorldMeshUpdateCallback callback) {
         _updateCallback = callback;
@@ -161,9 +233,10 @@ public:
 private:
     std::weak_ptr<VROPhysicsWorld> _physicsWorld;
 
-    // Bullet physics components (direct, without VROPhysicsBody wrapper)
-    btRigidBody* _rigidBody = nullptr;
-    btDefaultMotionState* _motionState = nullptr;
+    // Bullet physics components — smart pointers for exception-safe lifecycle.
+    // BulletRigidBodyDeleter removes the body from the world before deletion.
+    std::unique_ptr<btRigidBody, BulletRigidBodyDeleter> _rigidBody;
+    std::unique_ptr<btDefaultMotionState> _motionState;
     std::shared_ptr<VROPhysicsShape> _physicsShape;
 
     // Current mesh data
@@ -172,14 +245,21 @@ private:
     // Configuration and state
     VROWorldMeshConfig _config;
     bool _enabled = false;
+    bool _isAddedToPhysicsWorld = false;  // guard against re-add on rapid updates
 
     // Timing
     double _lastUpdateTimeMs = 0.0;
     double _lastDepthTimeMs = 0.0;
 
-    // Callback
+    // Legacy stats-only callback
     VROWorldMeshUpdateCallback _updateCallback;
 
+    // Subscriber registry
+    std::map<VROWorldMeshSubscriberId,
+             std::pair<VROWorldMeshSubscriberCallback, VROWorldMeshSubscriberOptions>> _subscribers;
+    VROWorldMeshSubscriberId _nextSubscriberId = 1;
+    mutable std::mutex _subscriberMutex;
+
     /**
      * Apply a new mesh to the physics world.
      * Creates a new physics shape and rigid body from the mesh.
@@ -210,6 +290,29 @@ private:
      * Check if the mesh is stale (depth data not received recently).
      */
     bool isMeshStale() const;
+
+    /**
+     * Fire the legacy _updateCallback and all registered subscribers.
+     * Called on the render thread after a mesh is successfully applied.
+     */
+    void notifySubscribers(std::shared_ptr<VROARDepthMesh> mesh);
+
+    /**
+     * Return a decimated copy of mesh with at most maxTriangles triangles,
+     * using Stride strategy (every N-th triangle). Vertices are copied as-is;
+     * only the index buffer is thinned. Returns mesh unchanged if already within budget.
+     */
+    static std::shared_ptr<VROARDepthMesh> decimateMesh(
+        std::shared_ptr<VROARDepthMesh> mesh, int maxTriangles);
+
+    /**
+     * Vertex-clustering simplification. Groups all vertices within cellSize metres
+     * into a single representative, rebuilds triangles, drops degenerate ones.
+     * Produces a gap-free mesh: max gap = sqrt(3)*cellSize.
+     * 0.10m cells → catches objects wider than ~8cm reliably.
+     */
+    static std::shared_ptr<VROARDepthMesh> clusterMesh(
+        std::shared_ptr<VROARDepthMesh> mesh, float cellSize);
 };
 
 #endif /* VROARWorldMesh_h */

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

@@ -51,6 +51,25 @@ public:
     virtual void setMuted(bool muted) = 0;
     virtual void seekToTime(float seconds) = 0;
 
+    /*
+     Streaming PCM API. Subclasses that support runtime PCM feeding override
+     these; the default no-ops preserve all existing non-streaming subclasses.
+
+     beginStreaming: configure the player for streaming mode (instead of
+       loading a file/blob). Must be called before play(). sampleRate is in
+       Hz; channels is 1 (mono) or 2 (stereo).
+
+     pushSamples: feed interleaved float PCM samples in the range [-1, 1].
+       Thread-safe — may be called from any thread (sim loop, TTS callback,
+       etc.). Returns the number of samples accepted; if the ring buffer is
+       full the excess is dropped.
+
+     isStreaming: true once beginStreaming has been called successfully.
+    */
+    virtual void beginStreaming(int sampleRate, int channels) {}
+    virtual size_t pushSamples(const float *data, size_t count) { return 0; }
+    virtual bool isStreaming() const { return false; }
+
 protected:
     std::shared_ptr<VROSoundDelegateInternal> _delegate;
 };

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

@@ -0,0 +1,95 @@
+//
+//  VROAudioPlayerStreamiOS.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 VROAudioPlayerStreamiOS_h
+#define VROAudioPlayerStreamiOS_h
+
+#include "VROAudioPlayer.h"
+#include "VROPCMRingBuffer.h"
+#include <memory>
+#include <atomic>
+
+#ifdef __OBJC__
+@class AVAudioEngine;
+@class AVAudioSourceNode;
+@class AVAudioFormat;
+#else
+// Forward declarations for non-ObjC translation units (Android, WASM).
+typedef void AVAudioEngine;
+typedef void AVAudioSourceNode;
+typedef void AVAudioFormat;
+#endif
+
+/*
+ Streaming PCM audio player for iOS using AVAudioEngine + AVAudioSourceNode.
+
+ Usage:
+   auto player = std::make_shared<VROAudioPlayerStreamiOS>();
+   player->beginStreaming(32000, 2);   // stereo @ 32 kHz
+   player->setVolume(1.0f);
+   player->play();
+   // from any thread:
+   player->pushSamples(floatBuffer, frameCount * channels);
+
+ The AVAudioSourceNode render block drains the VROPCMRingBuffer on the
+ real-time audio thread (no locks). If the ring is empty, silence is output.
+ Spatialisation (position / attenuation) is NOT applied here — this player
+ is for non-spatial streaming audio. Spatial streaming is tracked separately.
+*/
+class VROAudioPlayerStreamiOS : public VROAudioPlayer {
+
+public:
+
+    VROAudioPlayerStreamiOS();
+    virtual ~VROAudioPlayerStreamiOS();
+
+    // VROAudioPlayer overrides
+    void setup() override;
+    void setLoop(bool loop) override   {}  // streaming is continuous; loop is a no-op
+    void play() override;
+    void pause() override;
+    void setVolume(float volume) override;
+    void setMuted(bool muted) override;
+    void seekToTime(float seconds) override {}  // not meaningful for live PCM
+
+    // Streaming API
+    void beginStreaming(int sampleRate, int channels) override;
+    size_t pushSamples(const float *data, size_t count) override;
+    bool isStreaming() const override { return _streaming; }
+
+private:
+
+    void teardown();
+
+#ifdef __OBJC__
+    AVAudioEngine      *_engine     = nil;
+    AVAudioSourceNode  *_sourceNode = nil;
+    AVAudioFormat      *_format     = nil;
+#else
+    void *_engine     = nullptr;
+    void *_sourceNode = nullptr;
+    void *_format     = nullptr;
+#endif
+
+    std::shared_ptr<VROPCMRingBuffer> _ring;
+    std::atomic<bool> _playing  { false };
+    std::atomic<bool> _muted    { false };
+    std::atomic<float> _volume  { 1.0f  };
+    bool _streaming = false;
+};
+
+#endif /* VROAudioPlayerStreamiOS_h */

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

@@ -62,7 +62,23 @@ public:
      texture.
      */
     std::vector<float> getCameraIntrinsics() const;
-    
+
+    /*
+     Expose the underlying capture controller so that callers (e.g. VRTCameraTexture)
+     can invoke photo / video capture directly.
+     */
+    std::shared_ptr<VROAVCaptureController> getCaptureController() const {
+        return _controller;
+    }
+
+    // Convenience wrappers so callers don't need to import VROAVCaptureController.h.
+    void setUpdateListener(std::function<void(CMSampleBufferRef, std::vector<float>)> listener);
+    void capturePhoto(NSString *outputPath,
+                      std::function<void(bool, NSString *, NSString *)> onCaptured);
+    void startRecording(NSString *outputPath,
+                        std::function<void(bool, NSString *, NSString *)> onStarted);
+    void stopRecording(std::function<void(bool, NSString *, NSString *)> onStopped);
+
 private:
     
     /*

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

@@ -30,6 +30,7 @@
 #include <vector>
 #include "VRODefines.h"
 #include "VROSoundData.h"
+#include "VROVertexBuffer.h"
 
 class VROGeometry;
 class VROMaterial;
@@ -278,6 +279,16 @@ public:
     virtual std::shared_ptr<VRORenderTarget> newRenderTarget(VRORenderTargetType type, int numAttachments, int numImages,
                                                              bool enableMipmaps, bool needsDepthStencil) = 0;
     virtual std::shared_ptr<VROVertexBuffer> newVertexBuffer(std::shared_ptr<VROData> data) = 0;
+    /*
+     Create a vertex buffer with an explicit usage hint. Subclasses that don't
+     override this default get a Static buffer; subclasses that do override gain
+     mutable buffers via VROVertexBuffer::updateData(). Used by VRODynamicGeometry
+     and any other path that needs per-frame buffer updates.
+     */
+    virtual std::shared_ptr<VROVertexBuffer> newVertexBuffer(std::shared_ptr<VROData> data,
+                                                             VROVertexBufferUsage usage) {
+        return newVertexBuffer(data);
+    }
     virtual std::shared_ptr<VRORenderTarget> getDisplay() = 0;
     virtual std::shared_ptr<VROImagePostProcess> newImagePostProcess(std::shared_ptr<VROShaderProgram> shader) = 0;
     virtual std::shared_ptr<VROVideoTextureCache> newVideoTextureCache() = 0;
@@ -285,6 +296,15 @@ public:
     virtual std::shared_ptr<VROSound> newSound(std::string resource, VROResourceType resourceType, VROSoundType type) = 0;
     virtual std::shared_ptr<VROAudioPlayer> newAudioPlayer(std::shared_ptr<VROSoundData> data) = 0;
     virtual std::shared_ptr<VROAudioPlayer> newAudioPlayer(std::string path, bool isLocal) = 0;
+    /*
+     Create an audio player pre-configured for streaming PCM. The returned
+     player's beginStreaming(sampleRate, channels) must be called before play().
+     Default implementation falls back to a no-op stub so subclasses that
+     haven't yet implemented streaming still compile.
+    */
+    virtual std::shared_ptr<VROAudioPlayer> newStreamingAudioPlayer() {
+        return newAudioPlayer(std::string(""), true);   // stub — subclasses override
+    }
     virtual std::shared_ptr<VROTypefaceCollection> newTypefaceCollection(std::string typefaces, int size, VROFontStyle style, VROFontWeight weight) = 0;
     virtual void setSoundRoom(float sizeX, float sizeY, float sizeZ, std::string wallMaterial,
                               std::string ceilingMaterial, std::string floorMaterial) = 0;

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

@@ -0,0 +1,170 @@
+//
+//  VRODynamicGeometry.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 VRODynamicGeometry_h
+#define VRODynamicGeometry_h
+
+#include <memory>
+#include <stdint.h>
+#include "VROGeometry.h"
+
+class VROVertexBuffer;
+class VRODriver;
+
+/*
+ A geometry whose vertex buffers can be replaced in place every frame without
+ recreating the geometry, its sources/elements, or its underlying GPU substrate.
+
+ Use this when the data driving the mesh changes at render-loop frequency:
+   - Procedural mesh (marching cubes, voxels)
+   - External engines that emit vertex soup per tick (libsm64, soft-body sims)
+   - CPU skinning of formats ViroCore doesn't parse natively
+   - Visualisations of changing scientific data
+
+ The first iteration supports unindexed triangle soup only. The vertex buffers
+ are allocated once at construction with the supplied capacity. Subsequent
+ calls to setBuffers() that stay within capacity reuse the GPU buffers without
+ reallocation. Exceeding the capacity triggers a one-time reallocation and a
+ warning; size the initial capacity to the upper bound your producer will emit.
+
+ Attribute availability is declared at construction. Buffers passed to
+ setBuffers() for absent attributes must be null; mismatches are logged.
+
+ Typical use:
+
+     auto geom = std::make_shared<VRODynamicGeometry>(
+         driver,
+         maxVertices,                       // upper bound the producer will emit
+         VRODynamicGeometryFeatures::All    // positions + normals + uvs + colours
+     );
+     someNode->setGeometry(geom);
+     someNode->getGeometry()->setMaterials({myMaterial});
+
+     // each frame:
+     geom->setBuffers(positions, normals, uvs, colours, triangleCount);
+ */
+
+enum class VRODynamicGeometryFeatures : uint32_t {
+    None       = 0,
+    Positions  = 1 << 0,   // always implicitly required
+    Normals    = 1 << 1,
+    UVs        = 1 << 2,
+    Colors     = 1 << 3,
+    PosNorm    = Positions | Normals,
+    PosNormUV  = Positions | Normals | UVs,
+    All        = Positions | Normals | UVs | Colors,
+};
+
+inline VRODynamicGeometryFeatures operator|(VRODynamicGeometryFeatures a,
+                                            VRODynamicGeometryFeatures b) {
+    return static_cast<VRODynamicGeometryFeatures>(
+        static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
+}
+inline bool hasFeature(VRODynamicGeometryFeatures set,
+                       VRODynamicGeometryFeatures probe) {
+    return (static_cast<uint32_t>(set) & static_cast<uint32_t>(probe)) != 0;
+}
+
+class VRODynamicGeometry : public VROGeometry {
+
+public:
+
+    /*
+     Construct a dynamic geometry sized to hold up to maxVertices and configured
+     for the given attribute set. Allocates and hydrates one VBO per declared
+     attribute up front. Positions are always allocated.
+     */
+    VRODynamicGeometry(std::shared_ptr<VRODriver> driver,
+                       int maxVertices,
+                       VRODynamicGeometryFeatures features =
+                           VRODynamicGeometryFeatures::PosNormUV);
+
+    virtual ~VRODynamicGeometry();
+
+    /*
+     Replace the geometry's vertex data and triangle count.
+
+     - positions: required, vertexCount * 3 floats
+     - normals:   required iff Normals feature was declared at construction,
+                  else must be null
+     - uvs:       required iff UVs feature was declared, vertexCount * 2 floats
+     - colors:    required iff Colors feature was declared, vertexCount * 4
+                  RGBA8 bytes (0..255)
+     - triangleCount: number of triangles to draw; vertexCount = triangleCount * 3
+
+     vertexCount may not exceed maxVertices declared at construction without
+     triggering a one-time VBO reallocation (logged warning).
+
+     Safe to call from the render thread. Thread-safety with any other thread
+     calling setBuffers concurrently is the caller's responsibility.
+     */
+    void setBuffers(const float    *positions,
+                    const float    *normals,
+                    const float    *uvs,
+                    const uint8_t  *colors,
+                    int             triangleCount);
+
+    /*
+     Maximum vertex capacity declared at construction (or grown by a previous
+     overflowing setBuffers call).
+     */
+    int getMaxVertices() const { return _maxVertices; }
+
+    /*
+     Features (attributes) this dynamic geometry was constructed with.
+     */
+    VRODynamicGeometryFeatures getFeatures() const { return _features; }
+
+private:
+
+    std::weak_ptr<VRODriver> _driver;
+    VRODynamicGeometryFeatures _features;
+    int _maxVertices;
+    int _currentTriangleCount;
+
+    std::shared_ptr<VROVertexBuffer> _positionBuffer;
+    std::shared_ptr<VROVertexBuffer> _normalBuffer;
+    std::shared_ptr<VROVertexBuffer> _uvBuffer;
+    std::shared_ptr<VROVertexBuffer> _colorBuffer;
+
+    std::shared_ptr<VROGeometryElement> _triangleSoupElement;
+
+    /*
+     Allocate the per-attribute VBOs and wire up the parent VROGeometry's
+     sources/elements once. Called from the constructor.
+     */
+    void initBuffers();
+
+    /*
+     Helper: replace a VertexBuffer's data and forward to its updateData hook.
+     */
+    void updateBuffer(const std::shared_ptr<VROVertexBuffer> &buffer,
+                      const void *data,
+                      size_t byteSize);
+
+    /*
+     Like updateBuffer but pads the VROData to totalBytes with zeros so
+     VROGeometrySource's declared vertexCount stays consistent with the buffer
+     capacity (avoids VROByteBuffer over-read during bounding-box computation).
+     */
+    void updateBufferPadded(const std::shared_ptr<VROVertexBuffer> &buffer,
+                            const void *activeData, size_t activeBytes,
+                            size_t totalBytes);
+
+};
+
+#endif /* VRODynamicGeometry_h */

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

@@ -0,0 +1,87 @@
+//
+//  VRODynamicMeshNode.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 VRODynamicMeshNode_h
+#define VRODynamicMeshNode_h
+
+#include <memory>
+#include <vector>
+#include "VRONode.h"
+#include "VRODynamicGeometry.h"
+#include "VROVector3f.h"
+#include "VROVector2f.h"
+#include "VROVector4f.h"
+
+class VRODriver;
+
+/*
+ A VRONode that owns a VRODynamicGeometry and exposes a high-level typed
+ setBuffers() API, matching the output of simulation adapters (e.g. libsm64).
+
+ Typical use:
+
+     auto node = std::make_shared<VRODynamicMeshNode>();
+     scene->getRootNode()->addChildNode(node);
+     node->init(driver, maxVertices, VRODynamicGeometryFeatures::All);
+
+     // each frame, from a VROFrameListener:
+     node->setBuffers(positions, normals, uvs, colors, vertexCount);
+
+ init() must be called once with a valid driver (e.g. from sceneWillAppear)
+ before the first setBuffers() call. vertexCount = triangleCount * 3.
+
+ scratch buffers for float packing are owned by the node and reused every
+ frame to avoid per-frame heap allocation.
+ */
+class VRODynamicMeshNode : public VRONode {
+public:
+    VRODynamicMeshNode() = default;
+    ~VRODynamicMeshNode() override = default;
+
+    /*
+     Allocate the underlying VRODynamicGeometry sized to hold up to maxVertices.
+     Must be called once from the render thread (e.g. sceneWillAppear) before
+     any setBuffers() call.
+     */
+    void init(std::shared_ptr<VRODriver> driver,
+              int maxVertices,
+              VRODynamicGeometryFeatures features = VRODynamicGeometryFeatures::All);
+
+    /*
+     Replace the mesh data for the current frame. vertexCount = triangleCount * 3.
+     colors components must be in [0, 1]; they are converted to uint8 RGBA internally.
+     Safe to call from the render thread at frame rate.
+     */
+    void setBuffers(const std::vector<VROVector3f> &positions,
+                    const std::vector<VROVector3f> &normals,
+                    const std::vector<VROVector2f> &uvs,
+                    const std::vector<VROVector4f> &colors,
+                    int vertexCount);
+
+    std::shared_ptr<VRODynamicGeometry> getDynamicGeometry() const { return _dynGeom; }
+
+private:
+    std::shared_ptr<VRODynamicGeometry> _dynGeom;
+
+    // Scratch buffers reused every frame to avoid heap churn
+    std::vector<float>    _scratchPos;
+    std::vector<float>    _scratchNorm;
+    std::vector<float>    _scratchUV;
+    std::vector<uint8_t>  _scratchColor;
+};
+
+#endif /* VRODynamicMeshNode_h */

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

@@ -188,7 +188,11 @@ private:
     static bool processAnimations(const tinygltf::Model &gModel);
     static bool processKeyFrameAnimations(const tinygltf::Model &gModel,
                                          std::map<int, std::map<int, std::vector<int>>> &gltfAnimatedNodes);
-    static void flattenSkeletalKeyframeAnimations(
+    // Resample all of a skin's animation channels onto a single common time-grid and merge each
+    // joint's per-property channels into one index-aligned VROKeyframeAnimation. Replaces the old
+    // drop-mismatched-channels flatten (VIRO-5741) so mixed STEP/LINEAR, multi-time-grid glTF
+    // animations (e.g. Blender exports) play fully instead of freezing.
+    static void resampleSkeletalChannelsToCommonGrid(
             std::map<int, std::pair<int, std::vector<int>>> &skeletalAnimToNodeSkinPair,
             int skinIndex);
     static std::shared_ptr<VROKeyframeAnimation> convertChannelToKeyFrameAnimation(