fix: fix occlusion in android

doranteseduardo · doranteseduardo · commit d4b3e6fb9e62 · 2025-12-07T22:05:30.000-06:00
diff --git a/ViroRenderer/VROShaderFactory.cpp b/ViroRenderer/VROShaderFactory.cpp
@@ -1182,16 +1182,16 @@ std::shared_ptr<VROShaderModifier> VROShaderFactory::createOcclusionDepthModifie
      already has the correct texture coordinate transform applied.
      */
     std::vector<std::string> modifierCode = {
-        // Request the ar_depth_texture sampler via marker
-        "// @sampler ar_depth_texture",
+        // Use the AO map sampler which is bound to the depth texture by VROSceneRendererARCore
+        "uniform sampler2D ao_map;",
 
         // Near and far planes - passed as uniforms for dynamic projection matching
         "uniform highp float occlusion_z_near;",
         "uniform highp float occlusion_z_far;",
 
         // Sample real-world depth in meters from the depth texture
         // Use diffuse_texcoord directly - it's already transformed for camera orientation
-        "highp float z = texture(ar_depth_texture, _surface.diffuse_texcoord).r;",
+        "highp float z = texture(ao_map, _surface.diffuse_texcoord).r;",
 
         // Use the uniform values for near/far planes
         "highp float n = occlusion_z_near;",
@@ -1213,6 +1213,18 @@ std::shared_ptr<VROShaderModifier> VROShaderFactory::createOcclusionDepthModifie
         VROShaderEntryPoint::Fragment, modifierCode);
     modifier->setName("occlusion_depth");
 
+    modifier->setUniformBinder("occlusion_z_near", VROShaderProperty::Float,
+        [](VROUniform *uniform,
+           const VROGeometry *geometry, const VROMaterial *material) {
+            uniform->setFloat(0.1f);
+        });
+
+    modifier->setUniformBinder("occlusion_z_far", VROShaderProperty::Float,
+        [](VROUniform *uniform,
+           const VROGeometry *geometry, const VROMaterial *material) {
+            uniform->setFloat(100.0f);
+        });
+
     return modifier;
 }
 
diff --git a/android/sharedCode/src/main/cpp/VROSceneRendererARCore.cpp b/android/sharedCode/src/main/cpp/VROSceneRendererARCore.cpp
@@ -228,6 +228,12 @@ void VROSceneRendererARCore::renderWithTracking(const std::shared_ptr<VROARCamer
     if (occlusionMode != VROOcclusionMode::Disabled && frame->hasDepthData()) {
         depthTexture = frame->getDepthTexture();
 
+        // Ensure the depth texture is uploaded to GPU before rendering
+        // This is critical - without this, the texture exists but contains no data on GPU
+        if (depthTexture && !depthTexture->isHydrated()) {
+            depthTexture->prewarm(_driver);
+        }
+
         // Calculate the transform from Screen UV to Depth Texture UV
         // We use the background texture coordinates which match the camera image orientation
         VROVector3f BL, BR, TL, TR;
@@ -242,7 +248,7 @@ void VROSceneRendererARCore::renderWithTracking(const std::shared_ptr<VROARCamer
         m[1] = TR.y - TL.y;  m[5] = BL.y - TL.y;  m[9] = 0;  m[13] = TL.y;
         m[2] = 0;            m[6] = 0;            m[10]= 1;  m[14] = 0;
         m[3] = 0;            m[7] = 0;            m[11]= 0;  m[15] = 1;
-        
+
         depthTransform = VROMatrix4f(m);
     }
 
diff --git a/android/sharedCode/src/main/cpp/arcore/VROARFrameARCore.cpp b/android/sharedCode/src/main/cpp/arcore/VROARFrameARCore.cpp
@@ -315,122 +315,43 @@ std::shared_ptr<VROARPointCloud> VROARFrameARCore::getPointCloud() {
 #pragma mark - Depth Data
 
 void VROARFrameARCore::acquireDepthData() const {
-    // Only check once per frame
-    if (_depthDataChecked) {
-        return;
-    }
-    _depthDataChecked = true;
-
-    // Reset state
-    _depthDataAvailable = false;
-    _depthTexture = nullptr;
-    _depthConfidenceTexture = nullptr;
-    _depthWidth = 0;
-    _depthHeight = 0;
-
-    std::shared_ptr<VROARSessionARCore> session = _session.lock();
-    if (!session) {
-        return;
-    }
-    
-    // Check if depth mode is enabled
-    if (!session->isDepthModeEnabled()) {
-        return;
-    }
-
-    std::shared_ptr<VROARSessionARCore> session = _session.lock();
-    std::shared_ptr<VRODriver> driver = _driver.lock();
-    if (!session || !driver) {
-        return;
-    }
-
-    // Acquire depth image from ARCore
-    arcore::Image *depthImage = nullptr;
-    arcore::ImageRetrievalStatus status = _frame->acquireDepthImage(&depthImage);
-
-    if (status != arcore::ImageRetrievalStatus::Success || depthImage == nullptr) {
-        // Depth not available for this frame
-        return;
-    }
-
-    // Get depth image dimensions
-    _depthWidth = depthImage->getWidth();
-    _depthHeight = depthImage->getHeight();
-
-    if (_depthWidth <= 0 || _depthHeight <= 0) {
-        delete depthImage;
-        return;
-    }
-
-    // Get depth data (16-bit depth in millimeters)
-    const uint8_t *depthData = nullptr;
-    int depthDataLength = 0;
-    depthImage->getPlaneData(0, &depthData, &depthDataLength);
-
-    if (depthData == nullptr || depthDataLength <= 0) {
-        delete depthImage;
-        return;
-    }
-
-    // Create depth texture from the raw data
-    // ARCore provides depth as 16-bit unsigned integers in millimeters
-    // Convert to 32-bit float (in meters) for consistency with iOS and shader usage
-    int numPixels = _depthWidth * _depthHeight;
-    std::vector<float> floatDepthData(numPixels);
-
-    const uint16_t *depthData16 = reinterpret_cast<const uint16_t*>(depthData);
-    for (int i = 0; i < numPixels; i++) {
-        // Convert from millimeters (uint16) to meters (float)
-        floatDepthData[i] = static_cast<float>(depthData16[i]) / 1000.0f;
-    }
-
-    // Create VROData from the float depth data
-    std::shared_ptr<VROData> depthVROData = std::make_shared<VROData>(
-        floatDepthData.data(),
-        floatDepthData.size() * sizeof(float),
-        VRODataOwnership::Copy);
-    std::vector<std::shared_ptr<VROData>> dataVec = { depthVROData };
-
-    // Create the depth texture using R32F format
-    _depthTexture = std::make_shared<VROTexture>(VROTextureType::Texture2D,
-                                                  VROTextureFormat::R32F,
-                                                  VROTextureInternalFormat::R32F,
-                                                  false, // not sRGB
-                                                  VROMipmapMode::None,
-                                                  dataVec,
-                                                  _depthWidth, _depthHeight,
-                                                  std::vector<uint32_t>());
-
-    _depthDataAvailable = true;
-
-    // Clean up
-    delete depthImage;
-
-    pinfo("VROARFrameARCore: Acquired depth data %dx%d", _depthWidth, _depthHeight);
+    // Deprecated: Depth data is now managed by VROARSessionARCore
 }
 
 std::shared_ptr<VROTexture> VROARFrameARCore::getDepthTexture() {
-    acquireDepthData();
-    return _depthTexture;
+    std::shared_ptr<VROARSessionARCore> session = _session.lock();
+    if (session) {
+        return session->getDepthTexture();
+    }
+    return nullptr;
 }
 
 std::shared_ptr<VROTexture> VROARFrameARCore::getDepthConfidenceTexture() {
-    // Confidence texture acquisition can be implemented similarly
-    // For now, return nullptr as it's optional
-    return _depthConfidenceTexture;
+    return nullptr;
 }
 
 bool VROARFrameARCore::hasDepthData() const {
-    acquireDepthData();
-    return _depthDataAvailable;
+    std::shared_ptr<VROARSessionARCore> session = _session.lock();
+    if (session) {
+        return session->getDepthTexture() != nullptr;
+    }
+    return false;
 }
 
 int VROARFrameARCore::getDepthImageWidth() const {
-    return _depthWidth;
+    std::shared_ptr<VROARSessionARCore> session = _session.lock();
+    if (session && session->getDepthTexture()) {
+        return session->getDepthTexture()->getWidth();
+    }
+    return 0;
 }
 
 int VROARFrameARCore::getDepthImageHeight() const {
-    return _depthHeight;
+    std::shared_ptr<VROARSessionARCore> session = _session.lock();
+    if (session && session->getDepthTexture()) {
+        return session->getDepthTexture()->getHeight();
+    }
+    return 0;
 }
 
 #pragma mark - Scene Semantics
diff --git a/android/sharedCode/src/main/cpp/arcore/VROARFrameARCore.h b/android/sharedCode/src/main/cpp/arcore/VROARFrameARCore.h
@@ -112,11 +112,7 @@ class VROARFrameARCore : public VROARFrame {
     std::weak_ptr<VRODriver> _driver;
 
     // Cached depth texture (refreshed each frame)
-    mutable std::shared_ptr<VROTexture> _depthTexture;
     mutable std::shared_ptr<VROTexture> _depthConfidenceTexture;
-    mutable int _depthWidth = 0;
-    mutable int _depthHeight = 0;
-    mutable bool _depthDataAvailable = false;
     mutable bool _depthDataChecked = false;
 
     // Cached semantic data (refreshed each frame)
diff --git a/android/sharedCode/src/main/cpp/arcore/VROARSessionARCore.cpp b/android/sharedCode/src/main/cpp/arcore/VROARSessionARCore.cpp
@@ -28,6 +28,8 @@
 #include "VROARAnchor.h"
 #include "VROGeospatialAnchor.h"
 #include "VROARHitTestResult.h"
+#include "VROTextureSubstrateOpenGL.h"
+#include "VRODriverOpenGL.h"
 #include "VROARImageTargetAndroid.h"
 #include "VROARPlaneAnchor.h"
 #include "VROCameraTexture.h"
@@ -61,11 +63,18 @@ VROARSessionARCore::VROARSessionARCore(std::shared_ptr<VRODriverOpenGL> driver)
       _geospatialMode(arcore::GeospatialMode::Disabled),
       _cameraTextureId(0),
       _displayRotation(VROARDisplayRotation::R0), _rotatedImageDataLength(0),
-      _rotatedImageData(nullptr) {
+      _rotatedImageData(nullptr),
+      _driver(driver) {
 
   _session = nullptr;
   _frame = nullptr;
   _frameCount = 0;
+
+  // Sync occlusion mode with depth mode default
+  // Since depth mode defaults to Automatic, enable occlusion by default
+  if (_depthMode == arcore::DepthMode::Automatic) {
+    VROARSession::setOcclusionMode(VROOcclusionMode::DepthBased);
+  }
 }
 
 void VROARSessionARCore::setARCoreSession(
@@ -717,7 +726,9 @@ std::unique_ptr<VROARFrame> &VROARSessionARCore::updateFrame() {
       std::make_unique<VROARFrameARCore>(_frame, _viewport, shared_from_this());
 
   VROARFrameARCore *arFrame = (VROARFrameARCore *)_currentFrame.get();
+  arFrame->setDriver(_driver.lock());
   processUpdatedAnchors(arFrame);
+  updateDepthTexture();
 
   return _currentFrame;
 }
@@ -1591,3 +1602,124 @@ void VROARSessionARCore::setSemanticModeEnabled(bool enabled) {
         _semanticModeEnabled = false;
     }
 }
+
+void VROARSessionARCore::updateDepthTexture() {
+    // Limit log frequency to avoid spam
+    static int logCounter = 0;
+    if (logCounter++ % 60 == 0) {
+        pinfo("VROARSessionARCore::updateDepthTexture called (sampled)");
+    }
+
+    if (!isDepthModeEnabled()) {
+        // pinfo("VROARSessionARCore: Depth mode disabled, skipping update");
+        return;
+    }
+
+    // Acquire depth image from ARCore
+    arcore::Image *depthImage = nullptr;
+    arcore::ImageRetrievalStatus status = _frame->acquireDepthImage(&depthImage);
+
+    if (status != arcore::ImageRetrievalStatus::Success || depthImage == nullptr) {
+        // pwarn("VROARSessionARCore: Failed to acquire depth image. Status: %d", (int)status);
+        return;
+    }
+
+    int width = depthImage->getWidth();
+    int height = depthImage->getHeight();
+
+    if (width <= 0 || height <= 0) {
+        pwarn("VROARSessionARCore: Invalid depth image dimensions: %d x %d", width, height);
+        delete depthImage;
+        return;
+    }
+
+    // Get depth data (16-bit depth in millimeters)
+    const uint8_t *depthData = nullptr;
+    int depthDataLength = 0;
+    depthImage->getPlaneData(0, &depthData, &depthDataLength);
+
+    int rowStride = depthImage->getPlaneRowStride(0);
+
+    if (depthData == nullptr || depthDataLength <= 0) {
+        pwarn("VROARSessionARCore: Invalid depth data. Length: %d", depthDataLength);
+        delete depthImage;
+        return;
+    }
+
+    // Convert to float buffer
+    int numPixels = width * height;
+    if (_depthFloatBuffer.size() != numPixels) {
+        _depthFloatBuffer.resize(numPixels);
+    }
+
+    float *floatData = _depthFloatBuffer.data();
+    
+    // Handle row stride (padding)
+    if (rowStride > 0 && rowStride != width * 2) {
+        for (int y = 0; y < height; y++) {
+            const uint16_t *rowStart = reinterpret_cast<const uint16_t*>(depthData + y * rowStride);
+            for (int x = 0; x < width; x++) {
+                floatData[y * width + x] = (float)rowStart[x] * 0.001f;
+            }
+        }
+    } else {
+        // Optimized loop: direct pointer access (packed)
+        const uint16_t *depthData16 = reinterpret_cast<const uint16_t*>(depthData);
+        for (int i = 0; i < numPixels; i++) {
+            floatData[i] = (float)depthData16[i] * 0.001f; // mm to meters
+        }
+    }
+
+    // DEBUG: Log center depth value
+    if (numPixels > 0) {
+        int centerIdx = (height / 2) * width + (width / 2);
+        // pinfo("VROARSessionARCore: Depth update. Center val: %f, Width: %d, Height: %d", floatData[centerIdx], width, height);
+    }
+
+    // If texture doesn't exist, create it
+    if (!_depthTexture || _depthTexture->getWidth() != width || _depthTexture->getHeight() != height) {
+        pinfo("VROARSessionARCore: Creating new depth texture (size %d x %d)", width, height);
+        std::shared_ptr<VROData> depthVROData = std::make_shared<VROData>(
+            (void *)floatData, numPixels * sizeof(float), VRODataOwnership::Copy);
+        std::vector<std::shared_ptr<VROData>> dataVec = { depthVROData };
+
+        _depthTexture = std::make_shared<VROTexture>(VROTextureType::Texture2D,
+                                                      VROTextureFormat::R32F,
+                                                      VROTextureInternalFormat::R32F,
+                                                      false,
+                                                      VROMipmapMode::None,
+                                                      dataVec,
+                                                      width, height,
+                                                      std::vector<uint32_t>());
+        
+        _depthTexture->setMinificationFilter(VROFilterMode::Nearest);
+        _depthTexture->setMagnificationFilter(VROFilterMode::Nearest);
+        // Use Clamp which maps to GL_CLAMP_TO_EDGE for OpenGL ES compatibility
+        _depthTexture->setWrapS(VROWrapMode::Clamp);
+        _depthTexture->setWrapT(VROWrapMode::Clamp);
+    } else {
+        // Update existing texture
+        std::shared_ptr<VRODriver> driver = _driver.lock();
+        if (driver) {
+            VROTextureSubstrate *substrate = _depthTexture->getSubstrate(0, driver, true);
+            if (substrate) {
+                // We need to cast to OpenGL substrate to access GL ID, or use a generic update method if available.
+                // Since we are in VROARSessionARCore (Android specific), we can assume OpenGL.
+                VROTextureSubstrateOpenGL *glSubstrate = (VROTextureSubstrateOpenGL *)substrate;
+                std::pair<GLenum, GLuint> textureInfo = glSubstrate->getTexture();
+                GLenum target = textureInfo.first;
+                GLuint texId = textureInfo.second;
+                
+                glBindTexture(target, texId);
+                glTexSubImage2D(target, 0, 0, 0, width, height, GL_RED, GL_FLOAT, floatData);
+                glBindTexture(target, 0);
+            } else {
+                pwarn("VROARSessionARCore: Failed to get substrate for depth texture update");
+            }
+        } else {
+            pwarn("VROARSessionARCore: Driver expired, cannot update depth texture");
+        }
+    }
+
+    delete depthImage;
+}
diff --git a/android/sharedCode/src/main/cpp/arcore/VROARSessionARCore.h b/android/sharedCode/src/main/cpp/arcore/VROARSessionARCore.h
