Merge remote-tracking branch 'upstream/master' into improve_vdb_tool_2

Author: kmuseth

cmake/FindBlosc.cmake

@@ -419,9 +419,11 @@ if(NOT TARGET Blosc::blosc)
         set(${BLOSC_EXTERNAL_LIB}_LIBRARIES       ${${BLOSC_EXTERNAL_LIB}_LIBRARY_DEBUG})
       endif()
 
-      target_link_libraries(Blosc::blosc INTERFACE
-        $<$<CONFIG:Release>:${${BLOSC_EXTERNAL_LIB}_LIBRARY_RELEASE}>
-        $<$<CONFIG:Debug>:${${BLOSC_EXTERNAL_LIB}_LIBRARY_DEBUG}>)
+      if(${BLOSC_EXTERNAL_LIB}_LIBRARY_RELEASE OR ${BLOSC_EXTERNAL_LIB}_LIBRARY_DEBUG)
+        target_link_libraries(Blosc::blosc INTERFACE
+          $<$<CONFIG:Release>:${${BLOSC_EXTERNAL_LIB}_LIBRARY_RELEASE}>
+          $<$<CONFIG:Debug>:${${BLOSC_EXTERNAL_LIB}_LIBRARY_DEBUG}>)
+      endif()
 
     endforeach()
   endif()

nanovdb/nanovdb/GridHandle.h

@@ -400,6 +400,7 @@ GridHandle<BufferT>::deviceGrid(uint32_t n) const
 template<typename BufferT>
 void GridHandle<BufferT>::read(std::istream& is, const BufferT& pool)
 {
+    const std::streampos start = is.tellg();// remember where the raw buffer begins
     GridData data;
     is.read((char*)&data, sizeof(GridData));
     if (data.isValid()) {
@@ -410,7 +411,7 @@ void GridHandle<BufferT>::read(std::istream& is, const BufferT& pool)
             sum += data.mGridSize;
         }
         auto buffer = BufferT::create(size + sum, &pool);
-        is.seekg(-int64_t(sum + sizeof(GridData)), std::ios::cur);// rewind to start
+        is.seekg(start);// rewind to the start of the raw buffer
         is.read((char*)(buffer.data()), buffer.size());
         *this = GridHandle(std::move(buffer));
     } else {

nanovdb/nanovdb/unittest/TestNanoVDB.cc

@@ -8386,6 +8386,38 @@ TEST_F(TestNanoVDB, CustomStreamGridHandleIO)
     }
 }// CustomStreamGridHandleIO
 
+// make -j testNanoVDB && ./unittest/testNanoVDB --gtest_filter="*GridHandleReadMultiGridRawBuffer"
+TEST_F(TestNanoVDB, GridHandleReadMultiGridRawBuffer)
+{
+    std::vector<nanovdb::GridHandle<>> handles;
+    handles.emplace_back(nanovdb::tools::createLevelSetSphere<float>(20.0));
+    handles.emplace_back(nanovdb::tools::createLevelSetSphere<float>(40.0));
+    ASSERT_EQ(2u, handles.size());
+    ASSERT_NE(handles[0].bufferSize(), handles[1].bufferSize());
+
+    auto mergedHandle = nanovdb::mergeGrids<nanovdb::HostBuffer, std::vector>(handles);
+    ASSERT_EQ(2u, mergedHandle.gridCount());
+
+    std::stringstream stream(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
+    mergedHandle.write(stream);
+    stream.seekg(0);
+
+    nanovdb::GridHandle<> handle;
+    handle.read(stream);
+
+    EXPECT_EQ(mergedHandle.bufferSize(), handle.bufferSize());
+    EXPECT_EQ(2u, handle.gridCount());
+    for (uint32_t i = 0; i < handle.gridCount(); ++i) {
+        const auto* grid = handle.grid<float>(i);
+        ASSERT_TRUE(grid);
+        EXPECT_EQ(i, grid->gridIndex());
+        EXPECT_EQ(2u, grid->gridCount());
+        EXPECT_EQ(handles[i].bufferSize(), grid->gridSize());
+        EXPECT_TRUE(nanovdb::tools::validateChecksum(grid));
+        EXPECT_TRUE(nanovdb::tools::validateChecksum(grid, nanovdb::CheckMode::Full));
+    }
+}// GridHandleReadMultiGridRawBuffer
+
 // make -j testNanoVDB && ./unittest/testNanoVDB --gtest_filter="*strcpy"
 TEST_F(TestNanoVDB, strcpy)
 {

openvdb/openvdb/io/Archive.cc

@@ -800,9 +800,11 @@ Archive::readGridCompression(std::istream& is)
 {
     checkFormatVersion(is);
 
-    uint32_t c = COMPRESS_NONE;
-    is.read(reinterpret_cast<char*>(&c), sizeof(uint32_t));
-    io::setDataCompression(is, c);
+    if (getFormatVersion(is) >= OPENVDB_FILE_VERSION_NODE_MASK_COMPRESSION) {
+        uint32_t c = COMPRESS_NONE;
+        is.read(reinterpret_cast<char*>(&c), sizeof(uint32_t));
+        io::setDataCompression(is, c);
+    }
 }
 
 
@@ -978,6 +980,14 @@ Archive::readHeader(std::istream& is)
         // Prior to the introduction of Blosc, ZLIB was the default compression scheme.
         mCompression = (COMPRESS_ZIP | COMPRESS_ACTIVE_MASK);
     }
+    if (mFileVersion >= OPENVDB_FILE_VERSION_SELECTIVE_COMPRESSION &&
+        mFileVersion < OPENVDB_FILE_VERSION_NODE_MASK_COMPRESSION)
+    {
+        char isCompressed;
+        is.read(&isCompressed, sizeof(char));
+        mCompression = (isCompressed != 0 ? COMPRESS_ZIP : COMPRESS_NONE);
+    }
+
 
     // 6) Read the 16-byte (128-bit) uuid.
     std::string oldUuid = mUuid;

openvdb_ax/openvdb_ax/ast/AST.h

@@ -348,7 +348,7 @@ struct Variable : public Expression
     const Expression* basetype() const override { return this; }
     //
     size_t children() const override { return 0; }
-    const Node* child(const size_t) const override { return nullptr; }
+    const Node* child([[maybe_unused]] const size_t index) const override { return nullptr; }
     //
     inline const std::string& name() const { return mName; }
 
@@ -366,7 +366,7 @@ struct ValueBase : public Expression
     const Expression* basetype() const override { return this; }
     //
     size_t children() const override { return 0; }
-    const Node* child(const size_t) const override { return nullptr; }
+    const Node* child([[maybe_unused]] const size_t index) const override { return nullptr; }
 };
 
 
@@ -1665,7 +1665,7 @@ struct Keyword : public Statement
     /// @copybrief Node::children()
     size_t children() const override final { return 0; }
     /// @copybrief Node::child()
-    const Node* child(const size_t) const override final {
+    const Node* child([[maybe_unused]] const size_t index) const override final {
         return nullptr;
     }
     /// @brief  Query the keyword held on this node.

openvdb_ax/openvdb_ax/codegen/FunctionTypes.cc

@@ -20,6 +20,10 @@
 #include <llvm/Support/ModRef.h> // MemoryEffects
 #endif
 
+#include <limits>
+#include <vector>
+#include <set>
+
 namespace openvdb {
 OPENVDB_USE_VERSION_NAMESPACE
 namespace OPENVDB_VERSION_NAME {
@@ -100,7 +104,8 @@ inline ArgInfo llvmTypeToArgInfo(llvm::Type* in)
         in = in->getContainedType(0);
         ++nptrs;
     }
-    return ArgInfo(in, nptrs);
+    OPENVDB_ASSERT(nptrs < size_t(std::numeric_limits<uint8_t>::max()));
+    return ArgInfo(in, uint8_t(nptrs));
 }
 
 inline ArgInfoVector llvmTypeToArgInfo(const std::vector<llvm::Type*>& in)
@@ -705,6 +710,16 @@ Value IRFunctionBase::call(const Arguments& args,
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
+bool
+FunctionGroup::HasUniqueFunctionSymbols() const
+{
+    std::set<std::string> symset;
+    for (const auto& function : mFunctionList) {
+        if (!symset.insert(function->symbol()).second) return false;
+    }
+    return true;
+}
+
 bool
 FunctionGroup::HasUniqueTypeSignatures(llvm::LLVMContext& C) const
 {

openvdb_ax/openvdb_ax/codegen/FunctionTypes.h

@@ -1293,6 +1293,7 @@ struct OPENVDB_AX_API IRFunctionBase : public Function
             if (result->getType()->isPointerTy())
             {
 #if LLVM_VERSION_MAJOR <= 15
+                (void)this;
                 return Value(result, result->getType()->getPointerElementType());
 #else
                 ArgInfoVector unused;
@@ -1403,10 +1404,16 @@ struct OPENVDB_AX_API FunctionGroup
             const FunctionList& list)
         : mName(name)
         , mDoc(doc)
-        , mFunctionList(list) {}
+        , mFunctionList(list) {
+            // Can't verify signatures yet without an LLVM context, asserted on demand
+            OPENVDB_ASSERT(this->HasUniqueFunctionSymbols());
+        }
     ~FunctionGroup() = default;
 
-    /// @brief  Verify the function signatures in this group.
+    /// @brief  Verify the function symbol names in this group (must be unique).
+    bool HasUniqueFunctionSymbols() const;
+
+    /// @brief  Verify the function signatures in this group (must be unique).
     bool HasUniqueTypeSignatures(llvm::LLVMContext& C) const;
 
     /// @brief  Given a vector of args, automatically returns the best

openvdb_ax/openvdb_ax/test/backend/TestFunctionGroup.cc

@@ -90,7 +90,7 @@ axtestmulti(llvm::LLVMContext& C)
             }, voidty, "ax.i32x2")),
             Function::Ptr(new unittest_util::TestFunction({
                 ArgInfo(llvm::ArrayType::get(llvm::Type::getInt32Ty(C), 3), 1)
-            }, voidty, "ax.i32x2")),
+            }, voidty, "ax.i32x3")),
          }));
     return group;
 }

openvdb_houdini/openvdb_houdini/GeometryUtil.cc

@@ -198,17 +198,25 @@ drawFrustum(
 #if SYS_VERSION_MAJOR_INT >= 21
 openvdb::math::Transform::Ptr
 frustumTransformFromCamera(
-    const OBJ_CameraParms& camparms,
+    const UT_CameraParms& camparms,
     const UT_Matrix4D &cameratosop,
     float offset, float nearPlaneDist, float farPlaneDist,
     float voxelDepthSize, int voxelCountX)
 {
     // Eval camera parms
+#if SYS_VERSION_MAJOR_INT >= 22
+    const fpreal camAspect = camparms.pixelaspect;
+    const fpreal camFocal = camparms.focal;
+    const fpreal camAperture = camparms.aperture;
+    const fpreal camXRes = camparms.resx;
+    const fpreal camYRes = camparms.resy;
+#else
     const fpreal camAspect = camparms.aspect;
     const fpreal camFocal = camparms.focal;
     const fpreal camAperture = camparms.aperture;
     const fpreal camXRes = camparms.xres;
     const fpreal camYRes = camparms.yres;
+#endif
 
     nearPlaneDist += offset;
     farPlaneDist += offset;

openvdb_houdini/openvdb_houdini/GeometryUtil.h

@@ -53,7 +53,7 @@ drawFrustum(GU_Detail&, const openvdb::math::Transform&,
 #if SYS_VERSION_MAJOR_INT >= 21
 openvdb::math::Transform::Ptr
 frustumTransformFromCamera(
-    const OBJ_CameraParms&, const UT_Matrix4D&,
+    const UT_CameraParms&, const UT_Matrix4D&,
     float offset, float nearPlaneDist, float farPlaneDist,
     float voxelDepthSize = 1.0, int voxelCountX = 100);
 #else