RileyIds.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2020 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  Licensees have the
# right to incorporate the Software into other products for use by other
# authorized software licensees of Pixar, without fee. Except as expressly
# permitted herein, the Software may not be disclosed to third parties, copied
# or duplicated in any form, in whole or in part, without the prior written
# permission of Pixar.
#
# The copyright notices in the Software and this entire statement, including the
# above license grant, this restriction and the following disclaimer, must be
# included in all copies of the Software, in whole or in part, and all permitted
# derivative works of the Software, unless such copies or derivative works are
# solely in the form of machine-executable object code generated by a source
# language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL PIXAR BE
# LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

#ifndef _RILEY_RILEYID_H_
#define _RILEY_RILEYID_H_

#include <cstdint>

RILEY_NAMESPACE_ENTER

class CameraId
{
public:
    ~CameraId() = default;
    CameraId() noexcept;  // Default-construction yields the invalid id.
    explicit CameraId(uint32_t val) noexcept;

    bool operator==(const CameraId& rhs) const noexcept;
    bool operator!=(const CameraId& rhs) const noexcept;
    bool operator<(const CameraId& rhs) const noexcept;
    bool operator>(const CameraId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static CameraId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class ClippingPlaneId
{
public:
    ~ClippingPlaneId() = default;
    ClippingPlaneId() noexcept;  // Default-construction yields the invalid id.
    explicit ClippingPlaneId(uint32_t val) noexcept;

    bool operator==(const ClippingPlaneId& rhs) const noexcept;
    bool operator!=(const ClippingPlaneId& rhs) const noexcept;
    bool operator<(const ClippingPlaneId& rhs) const noexcept;
    bool operator>(const ClippingPlaneId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static ClippingPlaneId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class DisplayFilterId
{
public:
    ~DisplayFilterId() = default;
    DisplayFilterId() noexcept;  // Default-construction yields the invalid id.
    explicit DisplayFilterId(uint32_t val) noexcept;

    bool operator==(const DisplayFilterId& rhs) const noexcept;
    bool operator!=(const DisplayFilterId& rhs) const noexcept;
    bool operator<(const DisplayFilterId& rhs) const noexcept;
    bool operator>(const DisplayFilterId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static DisplayFilterId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class SampleFilterId
{
public:
    ~SampleFilterId() = default;
    SampleFilterId() noexcept;  // Default-construction yields the invalid id.
    explicit SampleFilterId(uint32_t val) noexcept;

    bool operator==(const SampleFilterId& rhs) const noexcept;
    bool operator!=(const SampleFilterId& rhs) const noexcept;
    bool operator<(const SampleFilterId& rhs) const noexcept;
    bool operator>(const SampleFilterId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static SampleFilterId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class GeometryInstanceId
{
public:
    ~GeometryInstanceId() = default;
    GeometryInstanceId() noexcept;  // Default-construction yields the invalid id.
    explicit GeometryInstanceId(uint32_t val) noexcept;

    bool operator==(const GeometryInstanceId& rhs) const noexcept;
    bool operator!=(const GeometryInstanceId& rhs) const noexcept;
    bool operator<(const GeometryInstanceId& rhs) const noexcept;
    bool operator>(const GeometryInstanceId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static GeometryInstanceId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class GeometryPrototypeId
{
public:
    ~GeometryPrototypeId() = default;
    GeometryPrototypeId() noexcept;  // Default-construction yields the invalid id.
    explicit GeometryPrototypeId(uint32_t val) noexcept;

    bool operator==(const GeometryPrototypeId& rhs) const noexcept;
    bool operator!=(const GeometryPrototypeId& rhs) const noexcept;
    bool operator<(const GeometryPrototypeId& rhs) const noexcept;
    bool operator>(const GeometryPrototypeId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static GeometryPrototypeId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class MaterialId
{
public:
    ~MaterialId() = default;
    MaterialId() noexcept;  // Default-construction yields the invalid id.
    explicit MaterialId(uint32_t val) noexcept;

    bool operator==(const MaterialId& rhs) const noexcept;
    bool operator!=(const MaterialId& rhs) const noexcept;
    bool operator<(const MaterialId& rhs) const noexcept;
    bool operator>(const MaterialId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static MaterialId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class DisplacementId
{
public:
    ~DisplacementId() = default;
    DisplacementId() noexcept;  // Default-construction yields the invalid id.
    explicit DisplacementId(uint32_t val) noexcept;

    bool operator==(const DisplacementId& rhs) const noexcept;
    bool operator!=(const DisplacementId& rhs) const noexcept;
    bool operator<(const DisplacementId& rhs) const noexcept;
    bool operator>(const DisplacementId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static DisplacementId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class IntegratorId
{
public:
    ~IntegratorId() = default;
    IntegratorId() noexcept;  // Default-construction yields the invalid id.
    explicit IntegratorId(uint32_t val) noexcept;

    bool operator==(const IntegratorId& rhs) const noexcept;
    bool operator!=(const IntegratorId& rhs) const noexcept;
    bool operator<(const IntegratorId& rhs) const noexcept;
    bool operator>(const IntegratorId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static IntegratorId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class LightInstanceId
{
public:
    ~LightInstanceId() = default;
    LightInstanceId() noexcept;  // Default-construction yields the invalid id.
    explicit LightInstanceId(uint32_t val) noexcept;

    bool operator==(const LightInstanceId& rhs) const noexcept;
    bool operator!=(const LightInstanceId& rhs) const noexcept;
    bool operator<(const LightInstanceId& rhs) const noexcept;
    bool operator>(const LightInstanceId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static LightInstanceId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class LightShaderId
{
public:
    ~LightShaderId() = default;
    LightShaderId() noexcept;  // Default-construction yields the invalid id.
    explicit LightShaderId(uint32_t val) noexcept;

    bool operator==(const LightShaderId& rhs) const noexcept;
    bool operator!=(const LightShaderId& rhs) const noexcept;
    bool operator<(const LightShaderId& rhs) const noexcept;
    bool operator>(const LightShaderId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static LightShaderId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class CoordinateSystemId
{
public:
    ~CoordinateSystemId() = default;
    CoordinateSystemId() noexcept;  // Default-construction yields the invalid id.
    explicit CoordinateSystemId(uint32_t val) noexcept;

    bool operator==(const CoordinateSystemId& rhs) const noexcept;
    bool operator!=(const CoordinateSystemId& rhs) const noexcept;
    bool operator<(const CoordinateSystemId& rhs) const noexcept;
    bool operator>(const CoordinateSystemId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static CoordinateSystemId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class RenderOutputId
{
public:
    ~RenderOutputId() = default;
    RenderOutputId() noexcept;  // Default-construction yields the invalid id.
    explicit RenderOutputId(uint32_t val) noexcept;

    bool operator==(const RenderOutputId& rhs) const noexcept;
    bool operator!=(const RenderOutputId& rhs) const noexcept;
    bool operator<(const RenderOutputId& rhs) const noexcept;
    bool operator>(const RenderOutputId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static RenderOutputId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class RenderTargetId
{
public:
    ~RenderTargetId() = default;
    RenderTargetId() noexcept;  // Default-construction yields the invalid id.
    explicit RenderTargetId(uint32_t val) noexcept;

    bool operator==(const RenderTargetId& rhs) const noexcept;
    bool operator!=(const RenderTargetId& rhs) const noexcept;
    bool operator<(const RenderTargetId& rhs) const noexcept;
    bool operator>(const RenderTargetId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static RenderTargetId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class DisplayId
{
public:
    ~DisplayId() = default;
    DisplayId() noexcept;  // Default-construction yields the invalid id.
    explicit DisplayId(uint32_t val) noexcept;

    bool operator==(const DisplayId& rhs) const noexcept;
    bool operator!=(const DisplayId& rhs) const noexcept;
    bool operator<(const DisplayId& rhs) const noexcept;
    bool operator>(const DisplayId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static DisplayId InvalidId() noexcept;

private:
    uint32_t m_val;
};

class RenderViewId
{
public:
    ~RenderViewId() = default;
    RenderViewId() noexcept;  // Default-construction yields the invalid id.
    explicit RenderViewId(uint32_t val) noexcept;

    bool operator==(const RenderViewId& rhs) const noexcept;
    bool operator!=(const RenderViewId& rhs) const noexcept;
    bool operator<(const RenderViewId& rhs) const noexcept;
    bool operator>(const RenderViewId& rhs) const noexcept;

    uint32_t AsUInt32() const noexcept;
    static RenderViewId InvalidId() noexcept;

private:
    uint32_t m_val;
};

// UserId values are stored by the Riley implementer, along the corresponding Riley entity, without
// any modifications. The Riley implementer shouldn't assume anything about these UserIds (e.g.
// they are not necessarily unique).
//
// The association between a UserId and the corresponding Riley Id stays constant until the Riley
// entity is destroyed.
//
// These ids are not intended to replace the Riley Ids. They are intended to be used by the Riley
// implementer to refer to a particular entity, in a way that is independent from the Riley API.
// They can be seen generalization of the name identifiers occasionally used by some entities (e.g.
// instances).
//
// For example, a Riley implementer could use UserId values in: log outputs, communication with
// external modules, AOVs outputs, etc...
class UserId
{
public:
    ~UserId() = default;
    UserId() noexcept;  // Default-construction yields the invalid id.
    explicit UserId(uint64_t val) noexcept;

    bool operator==(const UserId& rhs) const noexcept;
    bool operator!=(const UserId& rhs) const noexcept;
    bool operator<(const UserId& rhs) const noexcept;
    bool operator>(const UserId& rhs) const noexcept;

    uint64_t AsUInt64() const noexcept;
    static UserId DefaultId() noexcept;

private:
    uint64_t m_val;
};

inline CameraId::CameraId() noexcept : CameraId(InvalidId())
{}
inline CameraId::CameraId(uint32_t val) noexcept : m_val(val)
{}

inline bool CameraId::operator==(const CameraId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool CameraId::operator!=(const CameraId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool CameraId::operator<(const CameraId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool CameraId::operator>(const CameraId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t CameraId::AsUInt32() const noexcept
{
    return m_val;
}

inline CameraId CameraId::InvalidId() noexcept
{
    return CameraId(UINT32_MAX);
}

inline ClippingPlaneId::ClippingPlaneId() noexcept : ClippingPlaneId(InvalidId())
{}
inline ClippingPlaneId::ClippingPlaneId(uint32_t val) noexcept : m_val(val)
{}

inline bool ClippingPlaneId::operator==(const ClippingPlaneId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool ClippingPlaneId::operator!=(const ClippingPlaneId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool ClippingPlaneId::operator<(const ClippingPlaneId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool ClippingPlaneId::operator>(const ClippingPlaneId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t ClippingPlaneId::AsUInt32() const noexcept
{
    return m_val;
}

inline ClippingPlaneId ClippingPlaneId::InvalidId() noexcept
{
    return ClippingPlaneId(UINT32_MAX);
}

inline DisplayFilterId::DisplayFilterId() noexcept : DisplayFilterId(InvalidId())
{}
inline DisplayFilterId::DisplayFilterId(uint32_t val) noexcept : m_val(val)
{}

inline bool DisplayFilterId::operator==(const DisplayFilterId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool DisplayFilterId::operator!=(const DisplayFilterId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool DisplayFilterId::operator<(const DisplayFilterId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool DisplayFilterId::operator>(const DisplayFilterId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t DisplayFilterId::AsUInt32() const noexcept
{
    return m_val;
}

inline DisplayFilterId DisplayFilterId::InvalidId() noexcept
{
    return DisplayFilterId(UINT32_MAX);
}

inline SampleFilterId::SampleFilterId() noexcept : SampleFilterId(InvalidId())
{}
inline SampleFilterId::SampleFilterId(uint32_t val) noexcept : m_val(val)
{}

inline bool SampleFilterId::operator==(const SampleFilterId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool SampleFilterId::operator!=(const SampleFilterId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool SampleFilterId::operator<(const SampleFilterId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool SampleFilterId::operator>(const SampleFilterId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t SampleFilterId::AsUInt32() const noexcept
{
    return m_val;
}

inline SampleFilterId SampleFilterId::InvalidId() noexcept
{
    return SampleFilterId(UINT32_MAX);
}

inline GeometryInstanceId::GeometryInstanceId() noexcept : GeometryInstanceId(InvalidId())
{}
inline GeometryInstanceId::GeometryInstanceId(uint32_t val) noexcept : m_val(val)
{}

inline bool GeometryInstanceId::operator==(const GeometryInstanceId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool GeometryInstanceId::operator!=(const GeometryInstanceId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool GeometryInstanceId::operator<(const GeometryInstanceId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool GeometryInstanceId::operator>(const GeometryInstanceId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t GeometryInstanceId::AsUInt32() const noexcept
{
    return m_val;
}

inline GeometryInstanceId GeometryInstanceId::InvalidId() noexcept
{
    return GeometryInstanceId(UINT32_MAX);
}

inline GeometryPrototypeId::GeometryPrototypeId() noexcept : GeometryPrototypeId(InvalidId())
{}
inline GeometryPrototypeId::GeometryPrototypeId(uint32_t val) noexcept : m_val(val)
{}

inline bool GeometryPrototypeId::operator==(const GeometryPrototypeId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool GeometryPrototypeId::operator!=(const GeometryPrototypeId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool GeometryPrototypeId::operator<(const GeometryPrototypeId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool GeometryPrototypeId::operator>(const GeometryPrototypeId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t GeometryPrototypeId::AsUInt32() const noexcept
{
    return m_val;
}

inline GeometryPrototypeId GeometryPrototypeId::InvalidId() noexcept
{
    return GeometryPrototypeId(UINT32_MAX);
}

inline MaterialId::MaterialId() noexcept : MaterialId(InvalidId())
{}
inline MaterialId::MaterialId(uint32_t val) noexcept : m_val(val)
{}

inline bool MaterialId::operator==(const MaterialId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool MaterialId::operator!=(const MaterialId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool MaterialId::operator<(const MaterialId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool MaterialId::operator>(const MaterialId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t MaterialId::AsUInt32() const noexcept
{
    return m_val;
}

inline MaterialId MaterialId::InvalidId() noexcept
{
    return MaterialId(UINT32_MAX);
}

inline DisplacementId::DisplacementId() noexcept : DisplacementId(InvalidId())
{}
inline DisplacementId::DisplacementId(uint32_t val) noexcept : m_val(val)
{}

inline bool DisplacementId::operator==(const DisplacementId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool DisplacementId::operator!=(const DisplacementId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool DisplacementId::operator<(const DisplacementId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool DisplacementId::operator>(const DisplacementId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t DisplacementId::AsUInt32() const noexcept
{
    return m_val;
}

inline DisplacementId DisplacementId::InvalidId() noexcept
{
    return DisplacementId(UINT32_MAX);
}

inline IntegratorId::IntegratorId() noexcept : IntegratorId(InvalidId())
{}
inline IntegratorId::IntegratorId(uint32_t val) noexcept : m_val(val)
{}

inline bool IntegratorId::operator==(const IntegratorId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool IntegratorId::operator!=(const IntegratorId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool IntegratorId::operator<(const IntegratorId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool IntegratorId::operator>(const IntegratorId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t IntegratorId::AsUInt32() const noexcept
{
    return m_val;
}

inline IntegratorId IntegratorId::InvalidId() noexcept
{
    return IntegratorId(UINT32_MAX);
}

inline LightInstanceId::LightInstanceId() noexcept : LightInstanceId(InvalidId())
{}
inline LightInstanceId::LightInstanceId(uint32_t val) noexcept : m_val(val)
{}

inline bool LightInstanceId::operator==(const LightInstanceId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool LightInstanceId::operator!=(const LightInstanceId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool LightInstanceId::operator<(const LightInstanceId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool LightInstanceId::operator>(const LightInstanceId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t LightInstanceId::AsUInt32() const noexcept
{
    return m_val;
}

inline LightInstanceId LightInstanceId::InvalidId() noexcept
{
    return LightInstanceId(UINT32_MAX);
}

inline LightShaderId::LightShaderId() noexcept : LightShaderId(InvalidId())
{}
inline LightShaderId::LightShaderId(uint32_t val) noexcept : m_val(val)
{}

inline bool LightShaderId::operator==(const LightShaderId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool LightShaderId::operator!=(const LightShaderId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool LightShaderId::operator<(const LightShaderId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool LightShaderId::operator>(const LightShaderId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t LightShaderId::AsUInt32() const noexcept
{
    return m_val;
}

inline LightShaderId LightShaderId::InvalidId() noexcept
{
    return LightShaderId(UINT32_MAX);
}

inline CoordinateSystemId::CoordinateSystemId() noexcept : CoordinateSystemId(InvalidId())
{}
inline CoordinateSystemId::CoordinateSystemId(uint32_t val) noexcept : m_val(val)
{}

inline bool CoordinateSystemId::operator==(const CoordinateSystemId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool CoordinateSystemId::operator!=(const CoordinateSystemId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool CoordinateSystemId::operator<(const CoordinateSystemId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool CoordinateSystemId::operator>(const CoordinateSystemId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t CoordinateSystemId::AsUInt32() const noexcept
{
    return m_val;
}

inline CoordinateSystemId CoordinateSystemId::InvalidId() noexcept
{
    return CoordinateSystemId(UINT32_MAX);
}

inline RenderOutputId::RenderOutputId() noexcept : RenderOutputId(InvalidId())
{}
inline RenderOutputId::RenderOutputId(uint32_t val) noexcept : m_val(val)
{}

inline bool RenderOutputId::operator==(const RenderOutputId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool RenderOutputId::operator!=(const RenderOutputId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool RenderOutputId::operator<(const RenderOutputId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool RenderOutputId::operator>(const RenderOutputId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t RenderOutputId::AsUInt32() const noexcept
{
    return m_val;
}

inline RenderOutputId RenderOutputId::InvalidId() noexcept
{
    return RenderOutputId(UINT32_MAX);
}

inline RenderTargetId::RenderTargetId() noexcept : RenderTargetId(InvalidId())
{}
inline RenderTargetId::RenderTargetId(uint32_t val) noexcept : m_val(val)
{}

inline bool RenderTargetId::operator==(const RenderTargetId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool RenderTargetId::operator!=(const RenderTargetId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool RenderTargetId::operator<(const RenderTargetId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool RenderTargetId::operator>(const RenderTargetId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t RenderTargetId::AsUInt32() const noexcept
{
    return m_val;
}

inline RenderTargetId RenderTargetId::InvalidId() noexcept
{
    return RenderTargetId(UINT32_MAX);
}

inline DisplayId::DisplayId() noexcept : DisplayId(InvalidId())
{}
inline DisplayId::DisplayId(uint32_t val) noexcept : m_val(val)
{}

inline bool DisplayId::operator==(const DisplayId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool DisplayId::operator!=(const DisplayId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool DisplayId::operator<(const DisplayId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool DisplayId::operator>(const DisplayId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t DisplayId::AsUInt32() const noexcept
{
    return m_val;
}

inline DisplayId DisplayId::InvalidId() noexcept
{
    return DisplayId(UINT32_MAX);
}

inline RenderViewId::RenderViewId() noexcept : RenderViewId(InvalidId())
{}
inline RenderViewId::RenderViewId(uint32_t val) noexcept : m_val(val)
{}

inline bool RenderViewId::operator==(const RenderViewId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool RenderViewId::operator!=(const RenderViewId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool RenderViewId::operator<(const RenderViewId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool RenderViewId::operator>(const RenderViewId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint32_t RenderViewId::AsUInt32() const noexcept
{
    return m_val;
}

inline RenderViewId RenderViewId::InvalidId() noexcept
{
    return RenderViewId(UINT32_MAX);
}

inline UserId::UserId() noexcept : UserId(DefaultId())
{}
inline UserId::UserId(uint64_t val) noexcept : m_val(val)
{}

inline bool UserId::operator==(const UserId& rhs) const noexcept
{
    return (m_val == rhs.m_val);
}
inline bool UserId::operator!=(const UserId& rhs) const noexcept
{
    return (m_val != rhs.m_val);
}
inline bool UserId::operator<(const UserId& rhs) const noexcept
{
    return (m_val < rhs.m_val);
}
inline bool UserId::operator>(const UserId& rhs) const noexcept
{
    return (m_val > rhs.m_val);
}

inline uint64_t UserId::AsUInt64() const noexcept
{
    return m_val;
}

inline UserId UserId::DefaultId() noexcept
{
    return UserId(0ULL);
}

RILEY_NAMESPACE_HEADER_EXIT

#endif  //_RILEY_RILEYID_H_