distanceHeuristicQuery.h

Go to the documentation of this file.

//
// Copyright 2026 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDLOD_DISTANCE_HEURISTIC_QUERY_H
#define USDLOD_DISTANCE_HEURISTIC_QUERY_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/usdLod/api.h"
#include "pxr/usd/usdLod/heuristicQuery.h"
 
#include "pxr/base/gf/camera.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/range3d.h"
#include "pxr/base/gf/vec3f.h"
 
#include "pxr/base/vt/array.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdLodDistanceHeuristicQuery : public UsdLodHeuristicQuery
{
public:
    using Parent = UsdLodHeuristicQuery;
 
public:
    GfVec3f center = {0.0, 0.0, 0.0};
 
    GfRange3d extent;
 
    VtFloatArray thresholds;
 
    VtFloatArray blendThresholds;
 
public:
    UsdLodDistanceHeuristicQuery() = default;
    UsdLodDistanceHeuristicQuery(const UsdLodDistanceHeuristicQuery&) = default;
    UsdLodDistanceHeuristicQuery(UsdLodDistanceHeuristicQuery&&) = default;
 
    UsdLodDistanceHeuristicQuery(
        const TfToken& domainIn,
        const GfVec3f& centerIn = GfVec3f(0.0, 0.0, 0.0),
        const GfRange3d& extentIn = GfRange3d(),
        const VtFloatArray& thresholdsIn = VtFloatArray(),
        const VtFloatArray& blendThresholdsIn = VtFloatArray())
    : UsdLodHeuristicQuery(domainIn)
    , center(centerIn)
    , extent(extentIn)
    , thresholds(thresholdsIn)
    , blendThresholds(blendThresholdsIn)
    { }
 
    USDLOD_API
    virtual ~UsdLodDistanceHeuristicQuery();
 
 
    USDLOD_API
    double ComputeDistance(const GfVec3d& viewpoint,
                           const GfMatrix4d& transform) const;
 
    double ComputeDistance(const GfVec3d& viewpoint,
                           const GfMatrix4d& transform,
                           double prevDistance,
                           double hysteresis) const
    {
        const double distance = ComputeDistance(viewpoint, transform);
 
        if (prevDistance < distance - hysteresis) {
            // distance is increasing
            prevDistance = distance - hysteresis;
        } else if (prevDistance > distance + hysteresis) {
            // distance is decreasing
            prevDistance = distance + hysteresis;
        } else {
            // prevSize is still within the hysteresis window. No change.
        }
 
        return prevDistance;
    }
 
    USDLOD_API
    float ComputeLOD(double distance) const;
 
    float ComputeLOD(const GfVec3d& viewpoint,
                     const GfMatrix4d& transform) const
    {
        return ComputeLOD(ComputeDistance(viewpoint, transform));
    }
 
    float ComputeLOD(const GfVec3d& viewpoint,
                     const GfMatrix4d& transform,
                     double prevDistance,
                     double hysteresis,
                     double* distanceOut) const
    {
        return ComputeLOD(
            (*distanceOut = ComputeDistance(viewpoint, transform,
                                            prevDistance, hysteresis)));
    }
 
};
 
USDLOD_API
std::ostream& operator<<(std::ostream&, const UsdLodDistanceHeuristicQuery&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif