omni/avreality/rain/PuddleBaker.h

File members: omni/avreality/rain/PuddleBaker.h

// Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "IPuddleBaker.h"

#include <carb/Defines.h>
#include <carb/InterfaceUtils.h>
#include <carb/Types.h>

#include <pxr/usd/sdf/path.h>

// clang-format off
#include <omni/usd/UsdContextIncludes.h>
#include <omni/usd/UsdContext.h>
// clang-format on

#include <gsl/span>

#include <string>
#include <tuple>
#include <vector>

namespace omni::avreality::rain
{

class PuddleBaker
{
    IPuddleBaker* m_puddleBaker = nullptr;

public:
    PuddleBaker() = delete;

    CARB_ALWAYS_INLINE static void bake(std::string textureName,
                                        carb::Uint2 textureDims,
                                        carb::Float2 regionMin,
                                        carb::Float2 regionMax,
                                        gsl::span<const carb::Float2> puddlesPositions,
                                        gsl::span<const float> puddlesRadii,
                                        gsl::span<const float> puddlesDepths)
    {
        CARB_ASSERT(puddlesPositions.size() == puddlesRadii.size());
        CARB_ASSERT(puddlesPositions.size() == puddlesDepths.size());

        carb::getCachedInterface<IPuddleBaker>()->bake(textureName.c_str(), textureDims, regionMin, regionMax,
                                                       puddlesPositions.size(), puddlesPositions.data(),
                                                       puddlesRadii.data(), puddlesDepths.data());
    }

    CARB_ALWAYS_INLINE static void bake(std::string textureName,
                                        carb::Float2 regionMin,
                                        carb::Float2 regionMax,
                                        gsl::span<carb::Float2> puddlesPositions,
                                        gsl::span<float> puddlesRadii,
                                        gsl::span<float> puddlesDepths)
    {
        bake(textureName, { 1024u, 1024u }, regionMin, regionMax, puddlesPositions, puddlesRadii, puddlesDepths);
    }

    CARB_ALWAYS_INLINE static void assignShadersAccumulationMapTextureNames(
        gsl::span<std::tuple<const pxr::SdfPath, const std::string>> shaderPathsAndTextureNames,
        omni::usd::UsdContext* usdContext = nullptr)
    {
        std::string usdContextName = usdContext ? usdContext->getName() : "";
        std::vector<std::string> shaderPathsAsString;
        std::vector<std::tuple<const char* const, const char* const>> shaderPathsAndTextureNames_c;
        shaderPathsAsString.reserve(shaderPathsAndTextureNames.size());
        shaderPathsAndTextureNames_c.reserve(shaderPathsAndTextureNames.size());
        for (auto&& sptn : shaderPathsAndTextureNames)
        {
            shaderPathsAsString.push_back(std::get<0>(sptn).GetAsString());
            shaderPathsAndTextureNames_c.push_back({ shaderPathsAsString.back().c_str(), std::get<1>(sptn).c_str() });
        }

        carb::getCachedInterface<IPuddleBaker>()->assignShadersAccumulationMapTextureNames(
            gsl::span<std::tuple<const char* const, const char* const>>(
                shaderPathsAndTextureNames_c.data(), shaderPathsAndTextureNames_c.size()),
            usdContextName.c_str());
    }
};

} // namespace omni::avreality::rain