Removes D3DCaps from Context and Display, instead querying Renderer for support status.

src/libEGL/Display.cpp

@@ -110,22 +110,15 @@ bool Display::initialize()
         terminate();
         return error(status, false);
     }
-    D3DCAPS9 deviceCaps = mRenderer->getDeviceCaps();  // D3D9_REPLACE
     IDirect3D9 *d3d9 = mRenderer->getD3D(); // D3D9_REPLACE
     UINT adapter = mRenderer->getAdapter(); // D3D9_REPLACE
     D3DDEVTYPE deviceType = mRenderer->getDeviceType(); // D3D9_REPLACE
     IDirect3DDevice9 *device = mRenderer->getDevice(); // D3D9_REPLACE
 
-    mMinSwapInterval = 4;
-    mMaxSwapInterval = 0;
+    mMinSwapInterval = mRenderer->getMinSwapInterval();
+    mMaxSwapInterval = mRenderer->getMaxSwapInterval();
 
     // START D3D9_REPLACE
-    if (deviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE) {mMinSwapInterval = std::min(mMinSwapInterval, 0); mMaxSwapInterval = std::max(mMaxSwapInterval, 0);}
-    if (deviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)       {mMinSwapInterval = std::min(mMinSwapInterval, 1); mMaxSwapInterval = std::max(mMaxSwapInterval, 1);}
-    if (deviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)       {mMinSwapInterval = std::min(mMinSwapInterval, 2); mMaxSwapInterval = std::max(mMaxSwapInterval, 2);}
-    if (deviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE)     {mMinSwapInterval = std::min(mMinSwapInterval, 3); mMaxSwapInterval = std::max(mMaxSwapInterval, 3);}
-    if (deviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)      {mMinSwapInterval = std::min(mMinSwapInterval, 4); mMaxSwapInterval = std::max(mMaxSwapInterval, 4);}
-
     const D3DFORMAT renderTargetFormats[] =
     {
         D3DFMT_A1R5G5B5,
@@ -185,7 +178,7 @@ bool Display::initialize()
                         // FIXME: enumerate multi-sampling
 
                         configSet.add(currentDisplayMode, mMinSwapInterval, mMaxSwapInterval, renderTargetFormat, depthStencilFormat, 0,
-                                        deviceCaps.MaxTextureWidth, deviceCaps.MaxTextureHeight);
+                                      mRenderer->getMaxTextureWidth(), mRenderer->getMaxTextureHeight());
                     }
                 }
             }

src/libGLESv2/Context.cpp

@@ -260,19 +260,17 @@ void Context::makeCurrent(egl::Display *display, egl::Surface *surface)
 
     if (!mHasBeenCurrent)
     {
-        mDeviceCaps = mRenderer->getDeviceCaps(); // D3D9_REMOVE
-
-        mVertexDataManager = new VertexDataManager(this, mDevice);
+        mVertexDataManager = new VertexDataManager(this, mRenderer, mDevice);
         mIndexDataManager = new IndexDataManager(this, mDevice);
         mBlit = new Blit(mRenderer);
 
-        mSupportsShaderModel3 = mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0);
-        mMaximumPointSize = mDeviceCaps.MaxPointSize;
+        mSupportsShaderModel3 = mRenderer->getShaderModel3Support();
+        mMaximumPointSize = mRenderer->getMaxPointSize();
         mSupportsVertexTexture = mRenderer->getVertexTextureSupport();
         mSupportsNonPower2Texture = mRenderer->getNonPower2TextureSupport();
         mSupportsInstancing = mRenderer->getInstancingSupport();
 
-        mMaxTextureDimension = std::min(std::min((int)mDeviceCaps.MaxTextureWidth, (int)mDeviceCaps.MaxTextureHeight),
+        mMaxTextureDimension = std::min(std::min(mRenderer->getMaxTextureWidth(), mRenderer->getMaxTextureHeight()),
                                         (int)gl::IMPLEMENTATION_MAX_TEXTURE_SIZE);
         mMaxCubeTextureDimension = std::min(mMaxTextureDimension, (int)gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE);
         mMaxRenderbufferDimension = mMaxTextureDimension;
@@ -319,7 +317,7 @@ void Context::makeCurrent(egl::Display *display, egl::Surface *surface)
         mSupportsDepthTextures = mRenderer->getDepthTextureSupport();
         mSupportsTextureFilterAnisotropy = mRenderer->getTextureFilterAnisotropySupport();
 
-        mSupports32bitIndices = mDeviceCaps.MaxVertexIndex >= (1 << 16);
+        mSupports32bitIndices = mRenderer->get32BitIndexSupport();
 
         mNumCompressedTextureFormats = 0;
         if (supportsDXT1Textures())

src/libGLESv2/Context.h

@@ -521,8 +521,6 @@ class Context
 
     Blit *getBlitter() { return mBlit; }
 
-    const D3DCAPS9 &getDeviceCaps() { return mDeviceCaps; }
-
   private:
     DISALLOW_COPY_AND_ASSIGN(Context);
 
@@ -665,8 +663,6 @@ class Context
 
     IDirect3DStateBlock9 *mMaskedClearSavedState;
 
-    D3DCAPS9 mDeviceCaps;
-
     ResourceManager *mResourceManager;
 
     VertexDeclarationCache mVertexDeclarationCache;

src/libGLESv2/VertexDataManager.cpp

@@ -36,7 +36,7 @@ int elementsInBuffer(const VertexAttribute &attribute, int size)
     return (size - attribute.mOffset % stride + (stride - attribute.typeSize())) / stride;
 }
 
-VertexDataManager::VertexDataManager(Context *context, IDirect3DDevice9 *device) : mContext(context), mDevice(device)
+VertexDataManager::VertexDataManager(Context *context, renderer::Renderer *renderer, IDirect3DDevice9 *device) : mContext(context), mDevice(device)
 {
     for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
@@ -46,8 +46,7 @@ VertexDataManager::VertexDataManager(Context *context, IDirect3DDevice9 *device)
     }
 
     // D3D9_REPLACE
-    const D3DCAPS9 &caps = context->getDeviceCaps();
-    checkVertexCaps(caps.DeclTypes);
+    checkVertexCaps(renderer->getCapsDeclTypes());
 
     mStreamingBuffer = new StreamingVertexBuffer(mDevice, INITIAL_STREAM_BUFFER_SIZE);
 

src/libGLESv2/VertexDataManager.h

@@ -113,7 +113,7 @@ class StaticVertexBuffer : public ArrayVertexBuffer
 class VertexDataManager
 {
   public:
-    VertexDataManager(Context *context, IDirect3DDevice9 *backend);
+    VertexDataManager(Context *context, renderer::Renderer *renderer, IDirect3DDevice9 *backend);
     virtual ~VertexDataManager();
 
     void dirtyCurrentValue(int index) { mDirtyCurrentValue[index] = true; }

src/libGLESv2/renderer/Renderer.cpp

@@ -171,6 +171,35 @@ EGLint Renderer::initialize()
     // Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per the spec
     mSupportsTextureFilterAnisotropy = ((mDeviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) && (mDeviceCaps.MaxAnisotropy >= 2));
 
+    mMinSwapInterval = 4;
+    mMaxSwapInterval = 0;
+
+    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
+    {
+        mMinSwapInterval = std::min(mMinSwapInterval, 0);
+        mMaxSwapInterval = std::max(mMaxSwapInterval, 0);
+    }
+    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
+    {
+        mMinSwapInterval = std::min(mMinSwapInterval, 1);
+        mMaxSwapInterval = std::max(mMaxSwapInterval, 1);
+    }
+    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
+    {
+        mMinSwapInterval = std::min(mMinSwapInterval, 2);
+        mMaxSwapInterval = std::max(mMaxSwapInterval, 2);
+    }
+    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
+    {
+        mMinSwapInterval = std::min(mMinSwapInterval, 3);
+        mMaxSwapInterval = std::max(mMaxSwapInterval, 3);
+    }
+    if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
+    {
+        mMinSwapInterval = std::min(mMinSwapInterval, 4);
+        mMaxSwapInterval = std::max(mMaxSwapInterval, 4);
+    }
+
     static const TCHAR windowName[] = TEXT("AngleHiddenWindow");
     static const TCHAR className[] = TEXT("STATIC");
 
@@ -735,6 +764,46 @@ bool Renderer::getShareHandleSupport() const
     return isD3d9ExDevice() && !gl::perfActive();
 }
 
+bool Renderer::getShaderModel3Support() const
+{
+    return mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0);
+}
+
+float Renderer::getMaxPointSize() const
+{
+    return mDeviceCaps.MaxPointSize;
+}
+
+int Renderer::getMaxTextureWidth() const
+{
+    return (int)mDeviceCaps.MaxTextureWidth;
+}
+
+int Renderer::getMaxTextureHeight() const
+{
+    return (int)mDeviceCaps.MaxTextureHeight;
+}
+
+bool Renderer::get32BitIndexSupport() const
+{
+    return mDeviceCaps.MaxVertexIndex >= (1 << 16);
+}
+
+DWORD Renderer::getCapsDeclTypes() const
+{
+    return mDeviceCaps.DeclTypes;
+}
+
+int Renderer::getMinSwapInterval() const
+{
+    return mMinSwapInterval;
+}
+
+int Renderer::getMaxSwapInterval() const
+{
+    return mMaxSwapInterval;
+}
+
 D3DPOOL Renderer::getBufferPool(DWORD usage) const
 {
     if (mD3d9Ex != NULL)

src/libGLESv2/renderer/Renderer.h

@@ -91,7 +91,6 @@ class Renderer
     // Renderer capabilities
     virtual IDirect3DDevice9 *getDevice() {return mDevice;};  // D3D9_REPLACE
     virtual D3DADAPTER_IDENTIFIER9 *getAdapterIdentifier() {return &mAdapterIdentifier;}; // D3D9_REPLACE
-    virtual D3DCAPS9 getDeviceCaps() {return mDeviceCaps;};       // D3D9_REMOVE
     virtual IDirect3D9 *getD3D() {return mD3d9;}; // D3D9_REMOVE
     virtual UINT getAdapter() {return mAdapter;}; // D3D9_REMOVE
     virtual D3DDEVTYPE getDeviceType() {return mDeviceType;}; // D3D9_REMOVE
@@ -115,6 +114,15 @@ class Renderer
     virtual float getTextureMaxAnisotropy() const;
     virtual bool getShareHandleSupport() const;
 
+    virtual bool getShaderModel3Support() const;
+    virtual float getMaxPointSize() const;
+    virtual int getMaxTextureWidth() const;
+    virtual int getMaxTextureHeight() const;
+    virtual bool get32BitIndexSupport() const;
+    virtual DWORD getCapsDeclTypes() const; // D3D9_REPLACE
+    virtual int getMinSwapInterval() const;
+    virtual int getMaxSwapInterval() const;
+
     virtual D3DPOOL getBufferPool(DWORD usage) const;
     virtual D3DPOOL getTexturePool(DWORD usage) const;
 
@@ -145,6 +153,8 @@ class Renderer
     bool mSceneStarted;
     bool mSupportsNonPower2Textures;
     bool mSupportsTextureFilterAnisotropy;
+    int mMinSwapInterval;
+    int mMaxSwapInterval;
 
     // A pool of event queries that are currently unused.
     std::vector<IDirect3DQuery9*> mEventQueryPool;