Code to load the software renderer and initialize it. Build scripts copy the ...

core/win/d3d9/renderer_d3d9.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 36 matching lines @@
 #include "core/cross/features.h"
 #include "core/cross/types.h"
 #include "core/win/d3d9/buffer_d3d9.h"
 #include "core/win/d3d9/d3d_entry_points.h"
 #include "core/win/d3d9/draw_element_d3d9.h"
 #include "core/win/d3d9/effect_d3d9.h"
 #include "core/win/d3d9/param_cache_d3d9.h"
 #include "core/win/d3d9/primitive_d3d9.h"
 #include "core/win/d3d9/render_surface_d3d9.h"
 #include "core/win/d3d9/sampler_d3d9.h"
+#include "core/win/d3d9/software_renderer_d3d9.h"
 #include "core/win/d3d9/stream_bank_d3d9.h"
 #include "core/win/d3d9/texture_d3d9.h"
 #include "core/win/d3d9/utils_d3d9.h"
 
 namespace o3d {
 
 typedef std::vector<Effect*> EffectArray;
 typedef std::vector<RenderSurfaceBase*> RenderSurfaceBaseArray;
 typedef std::vector<State*> StateArray;
 typedef std::vector<Texture*> TextureArray;
@@ skipping 223 matching lines @@
     if (!SUCCEEDED(d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
                                           D3DDEVTYPE_HAL,
                                           d3d_display_mode.Format,
                                           D3DUSAGE_DEPTHSTENCIL,
                                           D3DRTYPE_SURFACE,
                                           depth_stencil_formats[i]))) {
       LOG(ERROR) << "Device does not support all required texture formats"
           << " for depth/stencil buffers.";
       return false;
     }
-  }  
+  }
 
   return true;
 }
 
 // Attempt to create a Direct3D9 object supporting the required caps. Return
 // NULL if the object cannot be created or if it does not support the caps.
 Renderer::InitStatus CreateDirect3D(Direct3DCreate9_Ptr d3d_create_function,
                                     LPDIRECT3D9* d3d,
                                     Features* features) {
   if (!d3d_create_function) {
@@ skipping 11 matching lines @@
     *d3d = NULL;
     return Renderer::GPU_NOT_UP_TO_SPEC;
   }
 
   return Renderer::SUCCESS;
 }
 
 // For certain GPU drivers we need to force anti-aliasing off to avoid a
 // a huge performance hit when certain types of windows are used on the same
 // desktop as O3D. This function returns true if O3D is running on one
-// of these GPUs/Drivers.  
+// of these GPUs/Drivers.
 bool ForceAntiAliasingOff(LPDIRECT3D9* d3d) {
   D3DADAPTER_IDENTIFIER9 identifier;
   HRESULT hr = (*d3d)->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier);
-  
+
   unsigned int vendor_id = identifier.VendorId;
   unsigned int device_id = identifier.DeviceId;
   unsigned int product = HIWORD(identifier.DriverVersion.HighPart);
   unsigned int version = LOWORD(identifier.DriverVersion.HighPart);
   unsigned int subversion = HIWORD(identifier.DriverVersion.LowPart);
   unsigned int build = LOWORD(identifier.DriverVersion.LowPart);
 
   // Disable ATI drivers 6.14.10.x where x is 6800 or lower.
   if (vendor_id == 4098 &&   // ATI
       product == 6 &&
       version == 14 &&
-      subversion == 10 && 
+      subversion == 10 &&
       build <= 6800) {
     return true;
-  } 
+  }
 
   return false;
 }
 
+namespace {
+// Returns whether the ForceSoftwareRenderer value of the Software\Google\o3d
+// key is non-zero.
+bool IsForceSoftwareRendererEnabled() {
+  HKEY key;
+  if (FAILED(RegOpenKeyEx(HKEY_CURRENT_USER,
+                          TEXT("Software\\Google\\o3d"),
+                          0,
+                          KEY_READ,
+                          &key))) {
+    return false;
+  }
+  
+  bool enabled = false;
+  DWORD type;
+  DWORD value;
+  DWORD size = sizeof(value);
+  if (SUCCEEDED(RegQueryValueEx(key,
+                                TEXT("ForceSoftwareRenderer"),
+                                NULL,
+                                &type,
+                                reinterpret_cast<LPBYTE>(&value),
+                                &size))) {
+    if (type == REG_DWORD && size == sizeof(value) && value) {
+      enabled = true;
+    }
+  }
+  RegCloseKey(key);
+
+  return enabled;
+}
+}
 
 // Helper function that gets the D3D Interface, checks the available
 // multisampling modes and selects the most advanced one available to create
 // a D3D Device with a back buffer containing depth and stencil buffers that
 // match the current display device.
 Renderer::InitStatus InitializeD3D9Context(
     HWND window,
     LPDIRECT3D9* d3d,
     LPDIRECT3DDEVICE9* d3d_device,
     D3DPRESENT_PARAMETERS* d3d_present_parameters,
     bool fullscreen,
     Features* features,
     int* out_width,
     int* out_height) {
 
-  // Try the hardware renderer first.
-  Renderer::InitStatus status_hardware = CreateDirect3D(
-      Direct3DCreate9, d3d, features);
+  // Check registry to see if the developer has opted to force the software
+  // renderer.
+  Renderer::InitStatus status_hardware;
+  if (IsForceSoftwareRendererEnabled()) {
+    // Simulate GPU not up to spec.
+    status_hardware = Renderer::GPU_NOT_UP_TO_SPEC;
+  } else {
+    // Create a hardware device.
+    status_hardware = CreateDirect3D(Direct3DCreate9, d3d, features);
+  }
+  
   if (status_hardware != Renderer::SUCCESS) {
     Renderer::InitStatus status_software = CreateDirect3D(
         Direct3DCreate9Software, d3d, features);
 
     // We should not be requiring caps that are not supported by the software
     // renderer.
     DCHECK(status_software != Renderer::GPU_NOT_UP_TO_SPEC);
 
     if (status_software != Renderer::SUCCESS) {
       // Report the hardware error. An error with the software renderer should
       // only mean that it is not available, which is normal.
       if (status_hardware == Renderer::INITIALIZATION_ERROR) {
         LOG(ERROR) << "Failed to create the initial D3D9 Interface";
       }
       return status_hardware;
     }
+
+    SetupSoftwareRenderer(*d3d);
   }
 
   D3DDISPLAYMODE d3ddm;
   if (!HR((*d3d)->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
     return Renderer::GPU_NOT_UP_TO_SPEC;
 
   // NOTE: make sure the backbuffer matches this format, as it is
-  // currently currently assumed to be 32-bit 8X8R8G8B
+  // currently assumed to be 32-bit 8X8R8G8B
 
   ZeroMemory(d3d_present_parameters, sizeof(*d3d_present_parameters));
   d3d_present_parameters->Windowed               = !fullscreen;
   d3d_present_parameters->SwapEffect             = D3DSWAPEFFECT_DISCARD;
   d3d_present_parameters->BackBufferFormat       = d3ddm.Format;
   d3d_present_parameters->EnableAutoDepthStencil = FALSE;
   d3d_present_parameters->AutoDepthStencilFormat = D3DFMT_UNKNOWN;
   // wait for vsync
   d3d_present_parameters->PresentationInterval   = D3DPRESENT_INTERVAL_ONE;
 
@@ skipping 1314 matching lines @@
   static int swizzle_table[] = { 2, 1, 0, 3, };
   return swizzle_table;
 }
 
 // This is a factory function for creating Renderer objects.  Since
 // we're implementing D3D9, we only ever return a D3D9 renderer.
 Renderer* Renderer::CreateDefaultRenderer(ServiceLocator* service_locator) {
   return RendererD3D9::CreateDefault(service_locator);
 }
 }  // namespace o3d