Sharing an initial Adaptive Grid prototype. In this case, it's not even a dense grid, it just contains a single background value and I've done the minimal work to make this compile with most of the required methods set to throw a not implemented error currently. No IO implemented. Some brief notes:

I'm using anadaptive:: namespace, this sits within anopenvdb/adaptive sub-directory and I'm calling thisAdaptiveTree. It derives fromTreeBase as we discussed and this is nested within aGrid as well and aliased toAdaptiveGrid.

I've introduced a newAllGridTypes alias that addsAdaptiveGridTypes toSparseGridTypes. Adaptive Grids are registered, but existing methods that callgrid.apply<GridTypes>() will not apply to new Adaptive Grids and will have to be intentionally extended if that is the desired behavior.

I introduced a newTreeTraits class to determine whether grids are adaptive or sparse and added a specialization to the relevant template classes. The main goal here was to not need to add new virtual methods or static member variables to the Tree class (or any other derived classes there might be in the wild). I've added logic to the interpolation routines to handle sparse vs adaptive trees, which can then be used in thePointAdvect class without further changes.

BoxSampler::sample(const TreeT& inTree, const Vec3R& inCoord,                    typename TreeT::ValueType& result){    ....    if constexpr (isSparseTree<TreeT>()) {        // sparse implementation    } else if constexpr (isAdaptiveTree<TreeT>()) {        // adaptive implementation    }    OPENVDB_THROW(NotImplementedError, "");}

This should be sufficient to get some conversation going as to how this kind of thing could work. It might make sense to consider using animpl sub-directory as we have done elsewhere, but where should the implementation for sparse trees and adaptive trees live? Should we just include both implementations in the body of this function as I've done here? Should we add a new sparse sub-directory and put the original implementation of this method there and then put the adaptive one in the adaptive sub-directory? How would this work for some of the much larger, more complicated methods? What about if we added more logic for handling dense trees? How is this going to work with explicit template instantiation?