glslfxResourceLayout.h

//
// Copyright 2022 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_HIO_GLSLFX_RESOURCE_LAYOUT_H
#define PXR_IMAGING_HIO_GLSLFX_RESOURCE_LAYOUT_H
 
#include "pxr/pxr.h"
 
#include "pxr/imaging/hio/types.h"
 
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/staticTokens.h"
 
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
 
#define HIO_GLSLFX_RESOURCE_LAYOUT_TOKENS       \
    (unknown)                                   \
    (block)                                     \
    ((inValue, "in"))                           \
    ((outValue, "out"))                         \
    ((inBlock, "in block"))                     \
    ((outBlock, "out block"))                   \
    ((inValueArray, "in array"))                \
    ((outValueArray, "out array"))              \
    ((inBlockArray, "in block array"))          \
    ((outBlockArray, "out block array"))        \
    ((uniformBlock, "uniform block"))           \
    ((bufferReadOnly, "buffer readOnly"))       \
    ((bufferReadWrite, "buffer readWrite"))     \
    (centroid)                                  \
    (sample)                                    \
    (smooth)                                    \
    (flat)                                      \
    (noperspective)
 
 
TF_DECLARE_PUBLIC_TOKENS(HioGlslfxResourceLayoutTokens, HIO_API,
                         HIO_GLSLFX_RESOURCE_LAYOUT_TOKENS);
 
class VtDictionary;
 
class HioGlslfxResourceLayout
{
public:
    enum class InOut {
        NONE,
        STAGE_IN,
        STAGE_OUT,
    };
 
    enum class Kind {
        NONE,
        VALUE,
        BLOCK,
        QUALIFIER,
        UNIFORM_VALUE,
        UNIFORM_BLOCK,
        UNIFORM_BLOCK_CONSTANT_PARAMS,
        BUFFER_READ_ONLY,
        BUFFER_READ_WRITE,
    };
 
    struct Member {
        Member(TfToken const & dataType,
               TfToken const & name,
               TfToken const & arraySize = TfToken(),
               TfToken const & qualifiers = TfToken())
            : dataType(dataType)
            , name(name)
            , arraySize(arraySize)
            { }
        TfToken dataType;
        TfToken name;
        TfToken arraySize;
        TfToken qualifiers;
    };
    using MemberVector = std::vector<Member>;
 
    struct Element {
        Element(InOut inOut = InOut::NONE,
                Kind kind = Kind::NONE,
                TfToken dataType = HioGlslfxResourceLayoutTokens->unknown,
                TfToken name = HioGlslfxResourceLayoutTokens->unknown,
                TfToken arraySize = TfToken(),
                TfToken qualifiers = TfToken())
            : inOut(inOut)
            , kind(kind)
            , location(-1)
            , dataType(dataType)
            , name(name)
            , qualifiers(qualifiers)
            , arraySize(arraySize)
            , aggregateName()
            , members()
            { }
        InOut inOut;
        Kind kind;
        int location;
        TfToken dataType;
        TfToken name;
        TfToken qualifiers;
        TfToken arraySize;
        TfToken aggregateName;
        MemberVector members;
    };
    using ElementVector = std::vector<Element>;
 
    enum class TextureType {
        TEXTURE,                // a texture
        SHADOW_TEXTURE,         // a texture used as a shadow
        ARRAY_TEXTURE,          // e.g. texture1DArray, texture2DArray, etc.
    };
 
    struct TextureElement {
        TextureElement(TfToken name,
                int dim,
                int bindingIndex,
                HioFormat format = HioFormatFloat32Vec4,
                TextureType textureType = TextureType::TEXTURE,
                int arraySize = 0)
            : name(name)
            , dim(dim)
            , bindingIndex(bindingIndex)
            , format(format)
            , textureType(textureType)
            , arraySize(arraySize)
            { }
        TfToken name;
        int dim;
        int bindingIndex;
        HioFormat format;
        TextureType textureType;
        int arraySize;
    };
    using TextureElementVector = std::vector<TextureElement>;
 
    HioGlslfxResourceLayout();
    ~HioGlslfxResourceLayout();
 
    HIO_API
    static void ParseLayout(
        ElementVector *result,
        TfToken const &shaderStage,
        VtDictionary const &layoutDict);
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif  // PXR_IMAGING_HIO_GLSLFX_RESOURCE_LAYOUT_H