Omniverse Realtime Viewer

#include <array>
using Mat4 = std::array<double, 16>;

static bool writeLocalMatrix(
    ovstage_instance_t* stage, ovstage_query_handle_t query,
    const Mat4& matrix, ovstage_ordinal_t ordinal)
{
    int64_t shape = 1;
    DLTensor tensor{};
    tensor.data = const_cast<double*>(matrix.data());
    tensor.device = {kDLCPU, 0};
    tensor.ndim = 1;
    tensor.dtype = {kDLFloat, 64, 16};
    tensor.shape = &shape;
    ovstage_write_data_t data{};
    data.tensors = &tensor;
    data.tensor_count = 1;
    data.semantic = OVSTAGE_SEMANTIC_MATRIX;
    return waitStageOperation(stage, ovstage_write_attribute(
        stage, query, {0, literal_to_ovx_string("omni:xform")}, ordinal,
        data, OVSTAGE_PRIM_MODE_UPSERT));
}

struct PendingPick {
    bool pending = false;
    int left = 0;
    int top = 0;
    int right = 0;
    int bottom = 0;
};

static bool enqueuePick(
    ovrtx_renderer_t* renderer,
    const std::string& renderProductPath,
    PendingPick& pendingPick,
    int renderWidth,
    int renderHeight)
{
    if (!pendingPick.pending || renderWidth <= 0 || renderHeight <= 0) return false;

    const ovrtx_pick_query_desc_t desc = {
        toOvxString(renderProductPath),
        static_cast<float>(pendingPick.left) / renderWidth,
        static_cast<float>(pendingPick.top) / renderHeight,
        static_cast<float>(pendingPick.right) / renderWidth,
        static_cast<float>(pendingPick.bottom) / renderHeight,
        0,
    };
    pendingPick = {};

    const ovrtx_enqueue_result_t pick = ovrtx_enqueue_pick_query(renderer, &desc);
    if (!ok(pick)) {
        printLastOvrtxError("Failed to enqueue pick query");
        return false;
    }
    return true;
}

#include <ovx/path_dictionary/path_dictionary.h>
#include <ovx/path_dictionary/path_dictionary_helper.h>
#include <ovx/path_dictionary/path_dictionary_utils.h>

#include <algorithm>
#include <cstring>
#include <vector>

static const DLTensor* findTensor(const ovrtx_render_var_output_t& output, const char* name)
{
    for (size_t i = 0; output.tensors && i < output.num_tensors; ++i) {
        if (output.tensors[i].name &&
            sameString(*output.tensors[i].name, name)) {
            return output.tensors[i].dl;
        }
    }
    return nullptr;
}

static const DLTensor* findParam(const ovrtx_render_var_output_t& output, const char* name)
{
    for (size_t i = 0; output.params && i < output.num_params; ++i) {
        if (sameString(output.params[i].name, name)) return &output.params[i].dl;
    }
    return nullptr;
}

static bool readU64(const DLTensor& tensor, size_t index, std::uint64_t& value)
{
    if (!tensor.data || tensor.dtype.lanes != 1) return false;
    const auto* base = static_cast<const std::uint8_t*>(tensor.data) + tensor.byte_offset;
    const size_t bytes = tensor.dtype.bits / 8;
    const int64_t stride = tensor.strides ? tensor.strides[0] : 1;
    const auto* ptr = base + index * static_cast<size_t>(stride) * bytes;

    value = 0;
    if (tensor.dtype.code == static_cast<std::uint8_t>(kDLUInt)) {
        std::memcpy(&value, ptr, std::min(bytes, sizeof(value)));
        return true;
    }
    return false;
}

static std::string resolvePrimPathId(ovrtx_renderer_t* renderer, ovx_primpath_t pathId)
{
    path_dictionary_instance_t dictionary = {};
    if (!ok(ovrtx_get_path_dictionary(renderer, &dictionary))) {
        printLastOvrtxError("Failed to get OVRTX path dictionary");
        return {};
    }

    std::vector<ovx_token_t> tokenBuffer(256);
    ovx_token_t* tokensPerPath[] = {nullptr};
    size_t tokenCounts[] = {0};
    size_t pathsProcessed = 0;

    ovx_api_result_t tokenResult = path_dictionary_get_tokens_from_paths(
        &dictionary,
        &pathId,
        1,
        tokenBuffer.data(),
        tokenBuffer.size(),
        tokensPerPath,
        tokenCounts,
        &pathsProcessed);
    if (tokenResult.status != OVX_API_SUCCESS || pathsProcessed != 1 || !tokensPerPath[0]) {
        return {};
    }

    std::vector<ovx_string_t> tokenStrings(tokenCounts[0]);
    ovx_api_result_t stringResult = path_dictionary_get_strings_from_tokens(
        &dictionary,
        tokensPerPath[0],
        tokenCounts[0],
        tokenStrings.data());
    if (stringResult.status != OVX_API_SUCCESS) {
        return {};
    }

    std::string path;
    for (ovx_string_t token : tokenStrings) {
        std::string segment = fromOvxString(token);
        if (segment.empty()) continue;
        if (segment.front() != '/') path.push_back('/');
        path += segment;
    }
    return path.empty() ? "/" : path;
}

static std::vector<std::string> decodePickPaths(
    ovrtx_renderer_t* renderer,
    const ovrtx_render_var_output_t& pickOutput)
{
    std::uint64_t magic = 0;
    std::uint64_t version = 0;
    std::uint64_t hitCount = 0;
    const DLTensor* magicParam = findParam(pickOutput, "magic");
    const DLTensor* versionParam = findParam(pickOutput, "version");
    const DLTensor* hitCountParam = findParam(pickOutput, "hitCount");
    if (!magicParam || !versionParam || !hitCountParam ||
        !readU64(*magicParam, 0, magic) ||
        !readU64(*versionParam, 0, version) ||
        !readU64(*hitCountParam, 0, hitCount)) {
        return {};
    }
    if (magic != OVRTX_PICK_HIT_MAGIC || version != OVRTX_PICK_HIT_VERSION) {
        return {};
    }

    const DLTensor* primPathTensor = findTensor(pickOutput, "primPath");
    if (!primPathTensor || !primPathTensor->shape) return {};

    const size_t count =
        std::min(static_cast<size_t>(hitCount), static_cast<size_t>(primPathTensor->shape[0]));

    std::vector<std::string> paths;
    for (size_t i = 0; i < count; ++i) {
        std::uint64_t id = 0;
        if (!readU64(*primPathTensor, i, id) || id == 0) continue;
        std::string path = resolvePrimPathId(renderer, static_cast<ovx_primpath_t>(id));
        if (!path.empty() && std::find(paths.begin(), paths.end(), path) == paths.end()) {
            paths.push_back(path);
        }
    }
    return paths;
}

const bool pickQueued = enqueuePick(renderer, renderProductPath, pendingPick, renderWidth, renderHeight);

// After ovrtx_step_with_stage() and ovrtx_fetch_results():
if (pickQueued && sameString(var.render_var_path, OVRTX_RENDER_VAR_PICK_HIT)) {
    ovrtx_map_output_description_t mapDesc = {};
    mapDesc.device_type = OVRTX_MAP_DEVICE_TYPE_CPU;
    ovrtx_render_var_output_t mapped = {};
    if (ok(ovrtx_map_render_var_output(renderer, var.output_handle,
            &mapDesc, ovrtx_timeout_infinite, &mapped)) &&
        mapped.status == OVRTX_EVENT_COMPLETED) {
        std::vector<std::string> picked = decodePickPaths(renderer, mapped);
        setSelectedPrim(picked.empty() ? std::string{} : picked.front());
    }
    if (mapped.map_handle != OVRTX_INVALID_HANDLE) {
        ovrtx_unmap_render_var_output(renderer, mapped.map_handle, {});
    }
}

static void setSelectionOutline(
    ovrtx_renderer_t* renderer,
    const std::string& previousPath,
    const std::string& nextPath)
{
    if (!previousPath.empty()) {
        const ovx_string_t path = toOvxString(previousPath);
        const uint8_t group = 0;
        waitForOperation(renderer,
            ovrtx_set_selection_outline_group_strings(renderer, &path, 1, &group),
            "Failed to clear selection outline");
    }
    if (!nextPath.empty()) {
        const ovx_string_t path = toOvxString(nextPath);
        const uint8_t group = 1;
        waitForOperation(renderer,
            ovrtx_set_selection_outline_group_strings(renderer, &path, 1, &group),
            "Failed to set selection outline");
    }
}