Merge pull request #2059 from sideeffects/send_upstream_houdini21sync

Synchronize with Houdini 21.

Author: jmlait

openvdb_houdini/openvdb_houdini/GEO_VDBTranslator.cc

@@ -14,9 +14,11 @@
 #include <UT/UT_ErrorManager.h>
 #include <UT/UT_IOTable.h>
 #include <UT/UT_IStream.h>
+#include <UT/UT_OFStream.h>
 #include <UT/UT_Version.h>
 
 #include <FS/FS_IStreamDevice.h>
+#include <FS/FS_WriterStream.h>
 #include <GA/GA_Stat.h>
 #include <GU/GU_Detail.h>
 #include <SOP/SOP_Node.h>
@@ -306,6 +308,16 @@ GEO_VDBTranslator::fileSave(const GEO_Detail *geogdp, std::ostream &os)
 GA_Detail::IOStatus
 GEO_VDBTranslator::fileSaveToFile(const GEO_Detail *geogdp, const char *fname)
 {
+    // When HOUDINI_VDB_FORCE_STREAM_SAVE is enabled, force saving via a stream
+    // that will NOT save grid offsets, disabling the ability to partial
+    // reading on the saved files. This is for reported performance issues with
+    // Qumulo file systems, that apparently Isilon file systems do not suffer
+    // from.
+    if (UT_EnvControl::getInt(ENV_HOUDINI_VDB_FORCE_STREAM_SAVE)) {
+        FS_WriterStream os(fname);
+        return fileSaveVDB<openvdb::io::Stream, std::ostream &>(geogdp, *os.getStream());
+    }
+
     // Saving via io::File will save grid offsets that allow for partial
     // reading.
     return fileSaveVDB<openvdb::io::File, const char *>(geogdp, fname);

openvdb_houdini/openvdb_houdini/GeometryUtil.cc

@@ -16,7 +16,6 @@
 #include <GA/GA_Types.h>
 #include <GU/GU_ConvertParms.h>
 #include <GU/GU_PrimPoly.h>
-#include <OBJ/OBJ_Camera.h>
 #include <UT/UT_BoundingBox.h>
 #include <UT/UT_String.h>
 #include <UT/UT_UniquePtr.h>
@@ -196,7 +195,72 @@ drawFrustum(
 
 ////////////////////////////////////////
 
+#if SYS_VERSION_MAJOR_INT >= 21
+openvdb::math::Transform::Ptr
+frustumTransformFromCamera(
+    const OBJ_CameraParms& camparms,
+    const UT_Matrix4D &cameratosop,
+    float offset, float nearPlaneDist, float farPlaneDist,
+    float voxelDepthSize, int voxelCountX)
+{
+    // Eval camera parms
+    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;
+
+    nearPlaneDist += offset;
+    farPlaneDist += offset;
+
+    const fpreal depth = farPlaneDist - nearPlaneDist;
+    const fpreal zoom = camAperture / camFocal;
+    const fpreal aspectRatio = camYRes / (camXRes * camAspect);
+
+    openvdb::Vec2d nearPlaneSize;
+    nearPlaneSize.x() = nearPlaneDist * zoom;
+    nearPlaneSize.y() = nearPlaneSize.x() * aspectRatio;
+
+    openvdb::Vec2d farPlaneSize;
+    farPlaneSize.x() = farPlaneDist * zoom;
+    farPlaneSize.y() = farPlaneSize.x() * aspectRatio;
+
+    // Create the linear map
+    openvdb::math::Mat4d xform(openvdb::math::Mat4d::identity());
+    xform.setToTranslation(openvdb::Vec3d(0, 0, -(nearPlaneDist - offset)));
+
+    /// this will be used to scale the frust to the correct size, and orient the
+    /// into the frustum as the negative z-direction
+    xform.preScale(openvdb::Vec3d(nearPlaneSize.x(), nearPlaneSize.x(), -nearPlaneSize.x()));
+
+    openvdb::math::Mat4d camxform(openvdb::math::Mat4d::identity());
+    for (unsigned i = 0; i < 4; ++i) {
+        for (unsigned j = 0; j < 4; ++j) {
+            camxform(i,j) = cameratosop(i,j);
+        }
+    }
+
+    openvdb::math::MapBase::Ptr linearMap(openvdb::math::simplify(
+        openvdb::math::AffineMap(xform * camxform).getAffineMap()));
 
+    // Create the non linear map
+    const int voxelCountY = int(std::ceil(float(voxelCountX) * aspectRatio));
+    const int voxelCountZ = int(std::ceil(depth / voxelDepthSize));
+
+    // the frustum will be the image of the coordinate in this bounding box
+    openvdb::BBoxd bbox(openvdb::Vec3d(0, 0, 0),
+        openvdb::Vec3d(voxelCountX, voxelCountY, voxelCountZ));
+    // define the taper
+    const fpreal taper = nearPlaneSize.x() / farPlaneSize.x();
+
+    // note that the depth is scaled on the nearPlaneSize.
+    // the linearMap will uniformly scale the frustum to the correct size
+    // and rotate to align with the camera
+    return openvdb::math::Transform::Ptr(new openvdb::math::Transform(
+        openvdb::math::MapBase::Ptr(new openvdb::math::NonlinearFrustumMap(
+            bbox, taper, depth/nearPlaneSize.x(), linearMap))));
+}
+#else
 openvdb::math::Transform::Ptr
 frustumTransformFromCamera(
     OP_Node& node, OP_Context& context, OBJ_Camera& cam,
@@ -281,7 +345,7 @@ frustumTransformFromCamera(
         openvdb::math::MapBase::Ptr(new openvdb::math::NonlinearFrustumMap(
             bbox, taper, depth/nearPlaneSize.x(), linearMap))));
 }
-
+#endif
 
 ////////////////////////////////////////
 

openvdb_houdini/openvdb_houdini/GeometryUtil.h

@@ -14,8 +14,10 @@
 #include <openvdb/util/NullInterrupter.h>
 #include <openvdb/util/Util.h> // for openvdb::util::COORD_OFFSETS
 
+#include <OBJ/OBJ_Camera.h>
 #include <GU/GU_Detail.h>
 #include <GEO/GEO_Primitive.h>
+#include <UT/UT_Version.h>
 
 #include <algorithm> // for std::max/min()
 #include <memory>
@@ -24,7 +26,6 @@
 
 
 class GA_SplittableRange;
-class OBJ_Camera;
 class OP_Context;
 class OP_Node;
 
@@ -51,13 +52,20 @@ drawFrustum(GU_Detail&, const openvdb::math::Transform&,
 
 
 /// Construct a frustum transform from a Houdini camera.
+#if SYS_VERSION_MAJOR_INT >= 21
+openvdb::math::Transform::Ptr
+frustumTransformFromCamera(
+    const OBJ_CameraParms&, const UT_Matrix4D&,
+    float offset, float nearPlaneDist, float farPlaneDist,
+    float voxelDepthSize = 1.0, int voxelCountX = 100);
+#else
 OPENVDB_HOUDINI_API
 openvdb::math::Transform::Ptr
 frustumTransformFromCamera(
     OP_Node&, OP_Context&, OBJ_Camera&,
     float offset, float nearPlaneDist, float farPlaneDist,
     float voxelDepthSize = 1.0, int voxelCountX = 100);
-
+#endif
 
 ////////////////////////////////////////
 

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Activate.cc

@@ -60,8 +60,8 @@ enum OPERATION_NAMES
 class SOP_VDBActivate : public hvdb::SOP_NodeVDB
 {
 public:
-    const char  *inputLabel(unsigned idx) const override;
-    int          isRefInput(unsigned i) const override;
+    const char  *inputLabel(OP_InputIdx idx) const override;
+    int          isRefInput(OP_InputIdx i) const override;
 
     bool         updateParmsFlags() override;
 
@@ -218,10 +218,10 @@ an inclusive range, so includes the maximum voxel.)"));
     support operation or setting of values.
 */
     parms.add(hutil::ParmFactory(PRM_INT, "expand", "Expand Voxels")
-                .setDefault(PRMoneDefaults)
+              .setDefault(PRMoneDefaults)
               .setRange(PRM_RANGE_UI, -5, PRM_RANGE_UI, 5)
               .setTooltip("Expand the active area by at least the specified number of voxels.")
-                .setDocumentation(
+              .setDocumentation(
 R"(Expand the active area by at least the specified number of voxels.  Does not support
 operation or setting of values.)"));
 

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Advect.cc

@@ -43,7 +43,11 @@ class SOP_OpenVDB_Advect: public hvdb::SOP_NodeVDB
 
     static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
 
-    int isRefInput(unsigned i) const override { return (i > 0); }
+    int isRefInput(OP_InputIdx i) const override
+    {
+        UT_ASSERT(i >= 0);
+        return (i > 0);
+    }
 
     class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
 

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Advect_Points.cc

@@ -626,7 +626,11 @@ class SOP_OpenVDB_Advect_Points: public hvdb::SOP_NodeVDB
 
     static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
 
-    int isRefInput(unsigned i ) const override { return (i > 0); }
+    int isRefInput(OP_InputIdx i) const override
+    {
+        UT_ASSERT(i >= 0);
+        return (i > 0);
+    }
 
     class Cache: public SOP_VDBCacheOptions
     {

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Analysis.cc

@@ -50,7 +50,11 @@ class SOP_OpenVDB_Analysis: public hvdb::SOP_NodeVDB
 
     static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
 
-    int isRefInput(unsigned i) const override { return (i == 1); }
+    int isRefInput(OP_InputIdx i) const override
+    {
+        UT_ASSERT(i >= 0);
+        return (i == 1);
+    }
 
     static const char* sOpName[];
 

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Clip.cc

@@ -17,6 +17,7 @@
 #include <openvdb/tools/Morphology.h> // for tools::dilateActiveValues(), tools::erodeActiveValues()
 #include <openvdb/points/PointDataGrid.h>
 #include <OBJ/OBJ_Camera.h>
+#include <UT/UT_Version.h>
 #include <cmath> // for std::abs(), std::round()
 #include <exception>
 #include <string>
@@ -35,7 +36,11 @@ class SOP_OpenVDB_Clip: public hvdb::SOP_NodeVDB
 
     static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
 
-    int isRefInput(unsigned input) const override { return (input == 1); }
+    int isRefInput(OP_InputIdx input) const override
+    {
+        UT_ASSERT(input >= 0);
+        return (input == 1);
+    }
 
     class Cache: public SOP_VDBCacheOptions
     {
@@ -109,7 +114,11 @@ Mask VDB:\n\
 
     parms.add(hutil::ParmFactory(PRM_STRING, "camera", "Camera")
         .setTypeExtended(PRM_TYPE_DYNAMIC_PATH)
+#if SYS_VERSION_MAJOR_INT >= 21
+        .setSpareData(&PRM_SpareData::anyCameraPath)
+#else
         .setSpareData(&PRM_SpareData::objCameraPath)
+#endif
         .setTooltip("Specify the path to a reference camera")
         .setDocumentation(
             "The path to the camera whose frustum is to be used as a clipping region"
@@ -430,11 +439,32 @@ SOP_OpenVDB_Clip::Cache::getFrustum(OP_Context& context)
     const auto time = context.getTime();
 
     UT_String cameraPath;
+    OBJ_CameraParms cameraParms;
     evalString(cameraPath, "camera", 0, time);
     if (!cameraPath.isstring()) {
         throw std::runtime_error{"no camera path was specified"};
     }
 
+#if SYS_VERSION_MAJOR_INT >= 21
+    UT_Matrix4D      cameratosop;
+    OBJ_Node        *meobj = cookparms()->getNode()
+                        ? cookparms()->getNode()->getCreator()->castToOBJNode()
+                        : nullptr;
+    UT_StringHolder  errstr;
+
+    OP_Node::getCameraInfoAndRelativeTransform(
+        cameraPath,
+        meobj ? meobj->getFullPath() : UT_StringHolder::theEmptyString,
+        cookparms()->getCwd(),
+        false, // get_inverse_xform
+        context,
+        cookparms()->depnode(),
+        cameraParms,
+        cameratosop,
+        errstr);
+    if (errstr.isstring())
+        throw std::runtime_error{"camera \"" + cameraPath.toStdString() + "\" was not found"};
+#else
     OBJ_Camera* camera = nullptr;
     if (auto* obj = cookparms()->getCwd()->findOBJNode(cameraPath)) {
         camera = obj->castToOBJCamera();
@@ -446,8 +476,9 @@ SOP_OpenVDB_Clip::Cache::getFrustum(OP_Context& context)
     }
     self->addExtraInput(camera, OP_INTEREST_DATA);
 
-    OBJ_CameraParms cameraParms;
     camera->getCameraParms(cameraParms, time);
+#endif
+
     if (cameraParms.projection != OBJ_PROJ_PERSPECTIVE) {
         throw std::runtime_error{cameraPath.toStdString() + " is not a perspective camera"};
         /// @todo support ortho and other cameras?
@@ -458,13 +489,18 @@ SOP_OpenVDB_Clip::Cache::getFrustum(OP_Context& context)
 
     const float nearPlane = (evalInt("setnear", 0, time)
         ? static_cast<float>(evalFloat("near", 0, time))
-        : static_cast<float>(camera->getNEAR(time))) - padding[2];
+        : static_cast<float>(cameraParms.mynear)) - padding[2];
     const float farPlane = (evalInt("setfar", 0, time)
         ? static_cast<float>(evalFloat("far", 0, time))
-        : static_cast<float>(camera->getFAR(time))) + padding[2];
+        : static_cast<float>(cameraParms.myfar)) + padding[2];
 
+#if SYS_VERSION_MAJOR_INT >= 21
+    mFrustum = hvdb::frustumTransformFromCamera(cameraParms, cameratosop,
+        /*offset=*/0.f, nearPlane, farPlane, /*voxelDepth=*/1.f, /*voxelCountX=*/100);
+#else
     mFrustum = hvdb::frustumTransformFromCamera(*self, context, *camera,
         /*offset=*/0.f, nearPlane, farPlane, /*voxelDepth=*/1.f, /*voxelCountX=*/100);
+#endif
 
     if (!mFrustum || !mFrustum->constMap<openvdb::math::NonlinearFrustumMap>()) {
         throw std::runtime_error{

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Combine.cc

@@ -129,7 +129,6 @@ asResampleMode(exint i, ResampleMode defaultMode = RESAMPLE_B)
         ? static_cast<ResampleMode>(i) : defaultMode;
 }
 
-
 //
 // Collation options
 //

openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Convert.cc

@@ -59,7 +59,11 @@ class SOP_OpenVDB_Convert: public hvdb::SOP_NodeVDB
 
     // Return true for a given input if the connector to the input
     // should be drawn dashed rather than solid.
-    int isRefInput(unsigned idx) const override { return (idx == 1); }
+    int isRefInput(OP_InputIdx idx) const override
+    {
+        UT_ASSERT(idx >= 0);
+        return (idx == 1);
+    }
 
 protected:
     bool updateParmsFlags() override;