meshSamplers.h

//
// Copyright 2017 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_IMAGING_PLUGIN_HD_EMBREE_MESH_SAMPLERS_H
#define PXR_IMAGING_PLUGIN_HD_EMBREE_MESH_SAMPLERS_H

#include "pxr/pxr.h"
#include "pxr/imaging/plugin/hdEmbree/sampler.h"
#include "pxr/imaging/hd/meshUtil.h"
#include "pxr/base/vt/types.h"

#include <embree3/rtcore.h>
#include <embree3/rtcore_geometry.h>

#include <bitset>

PXR_NAMESPACE_OPEN_SCOPE

class HdEmbreeRTCBufferAllocator
{
public:
    HdEmbreeRTCBufferAllocator()
        : _bitset(0) {}

    int Allocate();

    void Free(int buffer);

    unsigned int NumBuffers();

    static constexpr int PXR_MAX_USER_VERTEX_BUFFERS = 16;

private:
    std::bitset<PXR_MAX_USER_VERTEX_BUFFERS> _bitset;
};



// ----------------------------------------------------------------------
// The classes below implement the HdEmbreePrimvarSampler interface for
// the different interpolation modes that hydra supports. In some cases,
// implementations are broken out by geometry type (e.g. triangles vs
// subdiv).

class HdEmbreeConstantSampler : public HdEmbreePrimvarSampler {
public:
    HdEmbreeConstantSampler(TfToken const& name,
                            VtValue const& value)
        : _buffer(name, value)
        , _sampler(_buffer) {}

    virtual bool Sample(unsigned int element, float u, float v, void* value,
                        HdTupleType dataType) const;

private:
    HdVtBufferSource const _buffer;
    HdEmbreeBufferSampler const _sampler;
};

class HdEmbreeUniformSampler : public HdEmbreePrimvarSampler {
public:
    HdEmbreeUniformSampler(TfToken const& name,
                           VtValue const& value,
                           VtIntArray const& primitiveParams)
        : _buffer(name, value)
        , _sampler(_buffer)
        , _primitiveParams(primitiveParams) {}

    HdEmbreeUniformSampler(TfToken const& name,
                           VtValue const& value)
        : _buffer(name, value)
        , _sampler(_buffer) {}

    virtual bool Sample(unsigned int element, float u, float v, void* value,
                        HdTupleType dataType) const;

private:
    HdVtBufferSource const _buffer;
    HdEmbreeBufferSampler const _sampler;
    VtIntArray const _primitiveParams;
};

class HdEmbreeTriangleVertexSampler : public HdEmbreePrimvarSampler {
public:
    HdEmbreeTriangleVertexSampler(TfToken const& name,
                                  VtValue const& value,
                                  VtVec3iArray const& indices)
        : _buffer(name, value)
        , _sampler(_buffer)
        , _indices(indices) {}

    virtual bool Sample(unsigned int element, float u, float v, void* value,
                        HdTupleType dataType) const;

private:
    HdVtBufferSource const _buffer;
    HdEmbreeBufferSampler const _sampler;
    VtVec3iArray const _indices;
};

class HdEmbreeTriangleFaceVaryingSampler : public HdEmbreePrimvarSampler {
public:
    HdEmbreeTriangleFaceVaryingSampler(TfToken const& name,
                                       VtValue const& value,
                                       HdMeshUtil &meshUtil)
        : _buffer(name, _Triangulate(name, value, meshUtil))
        , _sampler(_buffer) {}

    virtual bool Sample(unsigned int element, float u, float v, void* value,
                        HdTupleType dataType) const;
    
private:
    HdVtBufferSource const _buffer;
    HdEmbreeBufferSampler const _sampler;

    // Pass the "value" parameter through HdMeshUtils'
    // ComputeTriangulatedFaceVaryingPrimvar(), which adjusts the primvar
    // buffer data for the triangulated topology. HdMeshUtil is provided
    // the source topology at construction time, so this class doesn't need
    // to provide it.
    static VtValue _Triangulate(TfToken const& name, VtValue const& value,
                                HdMeshUtil &meshUtil);
};

class HdEmbreeSubdivVertexSampler : public HdEmbreePrimvarSampler {
public:
    HdEmbreeSubdivVertexSampler(TfToken const& name,
                                VtValue const& value,
                                RTCScene meshScene,
                                unsigned meshId,
                                HdEmbreeRTCBufferAllocator *allocator);

    virtual ~HdEmbreeSubdivVertexSampler();

    virtual bool Sample(unsigned int element, float u, float v, void* value,
                        HdTupleType dataType) const;

private:
    int _embreeBufferId;
    HdVtBufferSource const _buffer;
    RTCScene _meshScene;
    unsigned _meshId;
    HdEmbreeRTCBufferAllocator *_allocator;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_IMAGING_PLUGIN_HD_EMBREE_MESH_SAMPLERS_H