types.h

//
// Copyright 2016 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_HD_TYPES_H
#define PXR_IMAGING_HD_TYPES_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/enums.h"
#include "pxr/imaging/hd/version.h"
#include "pxr/base/vt/value.h"
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
 
PXR_NAMESPACE_OPEN_SCOPE
 
enum HdWrap 
{
    HdWrapClamp,
    HdWrapRepeat,
    HdWrapBlack,
    HdWrapMirror,
 
    HdWrapNoOpinion,
    HdWrapLegacyNoOpinionFallbackRepeat, // deprecated
 
    HdWrapUseMetadata = HdWrapNoOpinion, // deprecated alias
    HdWrapLegacy = HdWrapLegacyNoOpinionFallbackRepeat // deprecated alias
};
 
enum HdMinFilter 
{
    HdMinFilterNearest,
    HdMinFilterLinear,
    HdMinFilterNearestMipmapNearest,
    HdMinFilterLinearMipmapNearest,
    HdMinFilterNearestMipmapLinear,
    HdMinFilterLinearMipmapLinear,
};
 
enum HdMagFilter 
{
    HdMagFilterNearest,
    HdMagFilterLinear,
};
 
enum HdBorderColor 
{
    HdBorderColorTransparentBlack,
    HdBorderColorOpaqueBlack,
    HdBorderColorOpaqueWhite,
};
 
class HdSamplerParameters {
public:
    HdWrap wrapS;
    HdWrap wrapT;
    HdWrap wrapR;
    HdMinFilter minFilter;
    HdMagFilter magFilter;
    HdBorderColor borderColor;
    bool enableCompare;
    HdCompareFunction compareFunction;
 
    HD_API
    HdSamplerParameters();   
 
    HD_API
    HdSamplerParameters(HdWrap wrapS, HdWrap wrapT, HdWrap wrapR, 
        HdMinFilter minFilter, HdMagFilter magFilter, 
        HdBorderColor borderColor=HdBorderColorTransparentBlack,
        bool enableCompare=false, 
        HdCompareFunction compareFunction=HdCmpFuncNever);
 
    HD_API 
    bool operator==(const HdSamplerParameters &other) const;
 
    HD_API
    bool operator!=(const HdSamplerParameters &other) const;
};
 
typedef uint32_t HdDirtyBits;
 
// GL Spec 2.3.5.2 (signed case, eq 2.4)
inline int HdConvertFloatToFixed(float v, int b)
{
    return int(
        std::round(
            std::min(std::max(v, -1.0f), 1.0f) * (float(1 << (b-1)) - 1.0f)));
}
 
// GL Spec 2.3.5.1 (signed case, eq 2.2)
inline float HdConvertFixedToFloat(int v, int b)
{
    return float(
        std::max(-1.0f,
            (v / (float(1 << (b-1)) - 1.0f))));
}
 
struct HdVec4f_2_10_10_10_REV
{
    HdVec4f_2_10_10_10_REV() { }
 
    template <typename Vec3Type>
    HdVec4f_2_10_10_10_REV(Vec3Type const &value) {
        x = HdConvertFloatToFixed(value[0], 10);
        y = HdConvertFloatToFixed(value[1], 10);
        z = HdConvertFloatToFixed(value[2], 10);
        w = 0;
    }
 
    HdVec4f_2_10_10_10_REV(int const value) {
        HdVec4f_2_10_10_10_REV const* other =
            reinterpret_cast<HdVec4f_2_10_10_10_REV const*>(&value);
        x = other->x;
        y = other->y;
        z = other->z;
        w = other->w;
    }
 
    template <typename Vec3Type>
    Vec3Type GetAsVec() const {
        return Vec3Type(HdConvertFixedToFloat(x, 10),
                        HdConvertFixedToFloat(y, 10),
                        HdConvertFixedToFloat(z, 10));
    }
 
    int GetAsInt() const {
        int const* asInt = reinterpret_cast<int const*>(this);
        return *asInt;
    }
 
    bool operator==(const HdVec4f_2_10_10_10_REV &other) const {
        return (other.w == w && 
                other.z == z && 
                other.y == y && 
                other.x == x);
    }
    bool operator!=(const HdVec4f_2_10_10_10_REV &other) const {
        return !(*this == other);
    }
 
    int x : 10;
    int y : 10;
    int z : 10;
    int w : 2;
};
 
enum HdType
{
    HdTypeInvalid=-1,
 
    HdTypeBool=0,
    HdTypeUInt8,
    HdTypeUInt16,
    HdTypeInt8,
    HdTypeInt16,
 
    HdTypeInt32,
    HdTypeInt32Vec2,
    HdTypeInt32Vec3,
    HdTypeInt32Vec4,
 
    HdTypeUInt32,
    HdTypeUInt32Vec2,
    HdTypeUInt32Vec3,
    HdTypeUInt32Vec4,
 
    HdTypeFloat,
    HdTypeFloatVec2,
    HdTypeFloatVec3,
    HdTypeFloatVec4,
    HdTypeFloatMat3,
    HdTypeFloatMat4,
 
    HdTypeDouble,
    HdTypeDoubleVec2,
    HdTypeDoubleVec3,
    HdTypeDoubleVec4,
    HdTypeDoubleMat3,
    HdTypeDoubleMat4,
 
    HdTypeHalfFloat,
    HdTypeHalfFloatVec2,
    HdTypeHalfFloatVec3,
    HdTypeHalfFloatVec4,
 
    HdTypeInt32_2_10_10_10_REV,
 
    HdTypeCount
};
 
struct HdTupleType {
    HdType type;
    size_t count;
 
    bool operator< (HdTupleType const& rhs) const {
        return (type < rhs.type) || (type == rhs.type && count < rhs.count);
    }
    bool operator== (HdTupleType const& rhs) const {
        return type == rhs.type && count == rhs.count;
    }
    bool operator!= (HdTupleType const& rhs) const {
        return !(*this == rhs);
    }
};
 
// Support TfHash.
template <class HashState>
void
TfHashAppend(HashState &h, HdTupleType const &tt)
{
    h.Append(tt.type, tt.count);
}
 
HD_API
const void* HdGetValueData(const VtValue &);
 
HD_API
HdTupleType HdGetValueTupleType(const VtValue &);
 
HD_API
HdType HdGetComponentType(HdType);
 
HD_API
size_t HdGetComponentCount(HdType t);
 
HD_API
size_t HdDataSizeOfType(HdType);
 
HD_API
size_t HdDataSizeOfTupleType(HdTupleType);
 
enum HdFormat
{
    HdFormatInvalid=-1,
 
    // UNorm8 - a 1-byte value representing a float between 0 and 1.
    // float value = (unorm / 255.0f);
    HdFormatUNorm8=0,
    HdFormatUNorm8Vec2,
    HdFormatUNorm8Vec3,
    HdFormatUNorm8Vec4,
 
    // SNorm8 - a 1-byte value representing a float between -1 and 1.
    // float value = max(snorm / 127.0f, -1.0f);
    HdFormatSNorm8,
    HdFormatSNorm8Vec2,
    HdFormatSNorm8Vec3,
    HdFormatSNorm8Vec4,
 
    // Float16 - a 2-byte IEEE half-precision float.
    HdFormatFloat16,
    HdFormatFloat16Vec2,
    HdFormatFloat16Vec3,
    HdFormatFloat16Vec4,
 
    // Float32 - a 4-byte IEEE float.
    HdFormatFloat32,
    HdFormatFloat32Vec2,
    HdFormatFloat32Vec3,
    HdFormatFloat32Vec4,
 
    // Int16 - a 2-byte signed integer
    HdFormatInt16,
    HdFormatInt16Vec2,
    HdFormatInt16Vec3,
    HdFormatInt16Vec4,
 
    // UInt16 - a 2-byte unsigned integer
    HdFormatUInt16,
    HdFormatUInt16Vec2,
    HdFormatUInt16Vec3,
    HdFormatUInt16Vec4,
 
    // Int32 - a 4-byte signed integer
    HdFormatInt32,
    HdFormatInt32Vec2,
    HdFormatInt32Vec3,
    HdFormatInt32Vec4,
 
    // Depth-stencil format
    HdFormatFloat32UInt8,
 
    HdFormatCount
};
 
HD_API
HdFormat HdGetComponentFormat(HdFormat f);
 
HD_API
size_t HdGetComponentCount(HdFormat f);
 
HD_API
size_t HdDataSizeOfFormat(HdFormat f);
 
using HdDepthStencilType = std::pair<float, uint32_t>;
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HD_TYPES_H