Introduce and use an enum class with just the device types we actually can handle.

Author: rpavlik

OsvrRenderingPlugin.cpp

@@ -168,16 +168,17 @@ inline void dispatchEventToRenderer(UnityRendererType renderer,
         return;
     }
     switch (renderer.getDeviceTypeEnum()) {
-#if SUPPORT_OPENGL
-    case kUnityGfxRendererOpenGL:
-        DoEventGraphicsDeviceOpenGL(eventType);
-        break;
-#endif
 #if SUPPORT_D3D11
-    case kUnityGfxRendererD3D11:
+    case OSVRSupportedRenderers::D3D11:
         DoEventGraphicsDeviceD3D11(eventType);
         break;
 #endif
+#if SUPPORT_OPENGL
+    case OSVRSupportedRenderers::OpenGL:
+        DoEventGraphicsDeviceOpenGL(eventType);
+        break;
+#endif
+    case OSVRSupportedRenderers::EmptyRenderer:
     default:
         break;
     }
@@ -323,15 +324,16 @@ OSVR_ReturnCode UNITY_INTERFACE_API ConstructRenderBuffers() {
     const int n = static_cast<int>(renderInfo.size());
     switch (s_deviceType.getDeviceTypeEnum()) {
 #if SUPPORT_D3D11
-    case kUnityGfxRendererD3D11:
+    case OSVRSupportedRenderers::D3D11:
         return applyRenderBufferConstructor(n, ConstructBuffersD3D11);
         break;
 #endif
 #if SUPPORT_OPENGL
-    case kUnityGfxRendererOpenGL:
+    case OSVRSupportedRenderers::OpenGL:
         return applyRenderBufferConstructor(n, ConstructBuffersOpenGL);
         break;
 #endif
+    case OSVRSupportedRenderers::EmptyRenderer:
     default:
         DebugLog("Device type not supported.");
         return OSVR_RETURN_FAILURE;
@@ -610,7 +612,7 @@ inline void DoRender() {
 
     switch (s_deviceType.getDeviceTypeEnum()) {
 #if SUPPORT_D3D11
-    case kUnityGfxRendererD3D11: {
+    case OSVRSupportedRenderers::D3D11: {
         // Render into each buffer using the specified information.
         for (int i = 0; i < n; ++i) {
             RenderViewD3D11(renderInfo[i],
@@ -631,7 +633,7 @@ inline void DoRender() {
     }
 #endif
 #if SUPPORT_OPENGL
-    case kUnityGfxRendererOpenGL: {
+    case OSVRSupportedRenderers::OpenGL: {
         // OpenGL
         //@todo OpenGL path is not working yet
         // Render into each buffer using the specified information.
@@ -649,6 +651,9 @@ inline void DoRender() {
         break;
     }
 #endif
+    case OSVRSupportedRenderers::EmptyRenderer:
+    default:
+        break;
     }
 }
 
@@ -700,7 +705,7 @@ inline void DoEventGraphicsDeviceD3D11(UnityGfxDeviceEventType eventType) {
         s_deviceType,
         "Should only be able to get in here with a valid device type.");
     BOOST_ASSERT_MSG(
-        s_deviceType.getDeviceTypeEnum == kUnityGfxRendererD3D11,
+        s_deviceType.getDeviceTypeEnum() == OSVRSupportedRenderers::D3D11,
         "Should only be able to get in here if using D3D11 device type.");
 
     switch (eventType) {
@@ -738,7 +743,7 @@ inline void DoEventGraphicsDeviceOpenGL(UnityGfxDeviceEventType eventType) {
         s_deviceType,
         "Should only be able to get in here with a valid device type.");
     BOOST_ASSERT_MSG(
-        s_deviceType.getDeviceTypeEnum == kUnityGfxRendererOpenGL,
+        s_deviceType.getDeviceTypeEnum() == OSVRSupportedRenderers::OpenGL,
         "Should only be able to get in here if using OpenGL device type.");
 
     switch (eventType) {

UnityRendererType.h

@@ -34,30 +34,42 @@
 // Standard includes
 // - none
 
+/// An enum class that only contains the renderer types that we support. This
+/// avoids spurious "unhandled cases in switch" warnings".
+enum class OSVRSupportedRenderers {
+    EmptyRenderer,
+#if SUPPORT_D3D11
+    D3D11,
+#endif
+#if SUPPORT_OPENGL
+    OpenGL,
+#endif
+};
+
 /// Wrapper around UnityGfxRenderer that knows about our support capabilities.
 class UnityRendererType {
   public:
     explicit operator bool() const { return supported_; }
-    UnityGfxRenderer getDeviceTypeEnum() const {
+    OSVRSupportedRenderers getDeviceTypeEnum() const {
         BOOST_ASSERT_MSG(supported_, "Cannot get an unsupported renderer!");
         return renderer_;
     }
-    UnityGfxRenderer getDeviceTypeEnumUnconditionally() const {
+    OSVRSupportedRenderers getDeviceTypeEnumUnconditionally() const {
         return renderer_;
     }
     UnityRendererType &operator=(UnityGfxRenderer gfxRenderer) {
-        BOOST_ASSERT_MSG(renderer_ == kUnityGfxRendererNull,
+        BOOST_ASSERT_MSG(renderer_ == OSVRSupportedRenderers::EmptyRenderer,
                          "Expect to only set renderer when it's null!");
         switch (gfxRenderer) {
 #if SUPPORT_OPENGL
         case kUnityGfxRendererOpenGL:
-            renderer_ = gfxRenderer;
+            renderer_ = OSVRSupportedRenderers::OpenGL;
             supported_ = true;
             break;
 #endif
 #if SUPPORT_D3D11
         case kUnityGfxRendererD3D11:
-            renderer_ = gfxRenderer;
+            renderer_ = OSVRSupportedRenderers::D3D11;
             supported_ = true;
             break;
 #endif
@@ -73,20 +85,19 @@ class UnityRendererType {
         case kUnityGfxRendererMetal:
         case kUnityGfxRendererD3D12:
         default:
-            renderer_ = kUnityGfxRendererNull;
-            supported_ = false;
+            reset();
             break;
         }
         return *this;
     }
 
     void reset() {
-        renderer_ = kUnityGfxRendererNull;
+        renderer_ = OSVRSupportedRenderers::EmptyRenderer;
         supported_ = false;
     }
 
   private:
-    UnityGfxRenderer renderer_ = kUnityGfxRendererNull;
+    OSVRSupportedRenderers renderer_ = OSVRSupportedRenderers::EmptyRenderer;
     bool supported_ = false;
 };