screenSizeHeuristicQuery.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_SCREENSIZE_HEURISTIC_QUERY_H
#define USDLOD_SCREENSIZE_HEURISTIC_QUERY_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/usdLod/api.h"
#include "pxr/usd/usdLod/heuristicQuery.h"
#include "pxr/usd/usdLod/tokens.h"
 
#include "pxr/base/gf/frustum.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 UsdLodScreenSizeHeuristicQuery : public UsdLodHeuristicQuery
{
public:
    using Parent = UsdLodHeuristicQuery;
 
public:
    GfRange3d extent;
 
    TfToken projectionMethod = UsdLodTokens->projectedSphere;
 
    VtFloatArray thresholds;
 
    VtFloatArray blendThresholds;
 
public:
    UsdLodScreenSizeHeuristicQuery() = default;
    UsdLodScreenSizeHeuristicQuery(const UsdLodScreenSizeHeuristicQuery&) = default;
    UsdLodScreenSizeHeuristicQuery(UsdLodScreenSizeHeuristicQuery&&) = default;
 
    UsdLodScreenSizeHeuristicQuery(
        const TfToken& domainIn,
        const GfRange3d extentIn = GfRange3d(),
        const TfToken& projectionMethodIn = UsdLodTokens->projectedSphere,
        const VtFloatArray& thresholdsIn = VtFloatArray(),
        const VtFloatArray& blendThresholdsIn = VtFloatArray())
    : UsdLodHeuristicQuery(domainIn)
    , extent(extentIn)
    , projectionMethod(projectionMethodIn)
    , thresholds(thresholdsIn)
    , blendThresholds(blendThresholdsIn)
    { }
 
    USDLOD_API
    virtual ~UsdLodScreenSizeHeuristicQuery();
 
 
    USDLOD_API
    double ComputeScreenSize(const GfFrustum& frustum,
                             const GfMatrix4d& transform) const;
 
    double ComputeScreenSize(const GfFrustum& frustum,
                             const GfMatrix4d& transform,
                             double prevSize,
                             double hysteresis) const
    {
        double screenSize = ComputeScreenSize(frustum, transform);
 
        if (prevSize < screenSize - hysteresis) {
            // screenSize is increasing
            prevSize = screenSize - hysteresis;
        } else if (prevSize > screenSize + hysteresis) {
            // screenSize is decreasing
            prevSize = screenSize + hysteresis;
        } else {
            // prevSize is still within the hysteresis window. No change.
        }
 
        return prevSize;
    }
 
    USDLOD_API
    float ComputeLOD(double size) const;
 
    float ComputeLOD(const GfFrustum& frustum,
                     const GfMatrix4d& transform) const
    {
        return ComputeLOD(ComputeScreenSize(frustum, transform));
    }
 
    float ComputeLOD(const GfFrustum& frustum,
                     const GfMatrix4d& transform,
                     double prevSize,
                     double hysteresis,
                     double* sizeOut) const
    {
        return ComputeLOD(
            (*sizeOut = ComputeScreenSize(frustum, transform,
                                          prevSize, hysteresis)));
    }
};
 
USDLOD_API
std::ostream& operator<<(std::ostream&, const UsdLodScreenSizeHeuristicQuery&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif