Improve API safety and standard-conformance by using Modern C++

OpenVR uses Modern C++ constructs already (see #1314), but the API is suboptimal in terms of safety. Some examples:

C-style includes are being used (e.g. stdint.h instead of cstdint). This helps with C++ Standard conformance.
constexpr is not being used for compile-time constants. It is stronger than const as it guarantees that the initialization expression is known at compile-time. E.g.

// Current:
static const uint32_t k_nSteamVRVersionMajor = 1;

// Proposed:
static constexpr uint32_t k_nSteamVRVersionMajor = 1;

typedef is being used instead of using. The latter is more readable. E.g.

// Current:
typedef uint32_t SpatialAnchorHandle_t;

// Proposed:
using SpatialAnchorHandle_t = std::uint32_t;

Unscoped enum is used instead of enum class, leading to vr:: namespace pollution and unwanted implicit conversions. E.g.

// Current:
enum EVREye
{
    Eye_Left = 0,
    Eye_Right = 1
};

// Proposed
enum class EVREye : int
{
    Left = 0,
    Right = 1
};

Easily-replaceable macros are being used. This avoid name collisions and helps have everything in the vr:: namespace. E.g.

// Current:
#define INVALID_SHARED_TEXTURE_HANDLE   ((vr::SharedTextureHandle_t)0)

// Proposed:
static constexpr vr::SharedTextureHandle_t invalidSharedTextureHandle{nullptr};

// Current:
#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )

// Proposed:
[[nodiscard]] constexpr std::uint32_t getCompositorAdditionalPredictedFrames(const Compositor_FrameTiming& timing)
{
    return (timing.m_nReprojectionFlags & vr::VRCompositor_PredictionMask) >> 4;
}

The [[nodiscard]] attribute is not being used. It is an extremely important attribute that can help avoid critical bugs, as it warns when a return value is not used. Most of the return values in the OpenVR API should be inspected by the caller, and not ignored! That is a source of common bugs. E.g.

// Current:
/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
    * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
    * Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
    virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;

// Proposed:
/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
    * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
    * Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
    [[nodiscard]] virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;

All the above are changes that do not require any standard library support, and can really improve the readability and safety of the API (especially [[nodiscard]]). There are also other possible improvements that require library support, like usage of std::string_view instead of const char* or std::string. That could lead to performance improvements in cases like the following:

// Current:
void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
        {
            m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
        }

// Proposed:
void SetString( std::string_view sSection, std::string_view sSettingsKey, std::string_view sValue, EVRSettingsError *peError = nullptr )
        {
            m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
        }

I could make a fork of the API targeted to Modern C++ users, but I'd rather improve openvr instead of branching out. I am happy to contribute, but first I'd like to know what your policy is and see the outcome of #1314.

ValveSoftware / openvr

Improve API safety and standard-conformance by using Modern C++ #1315