ES31: Implement multisampled Textures for D3D part.

src/compiler/translator/TextureFunctionHLSL.cpp

@@ -231,6 +231,8 @@ int GetHLSLCoordCount(const TextureFunctionHLSL::TextureFunction &textureFunctio
         {
             case EbtSampler2D:
                 return 2;
+            case EbtSampler2DMS:
+                return 2;
             case EbtSampler3D:
                 return 3;
             case EbtSamplerCube:
@@ -241,6 +243,8 @@ int GetHLSLCoordCount(const TextureFunctionHLSL::TextureFunction &textureFunctio
                 return 2;
             case EbtISampler2D:
                 return 2;
+            case EbtISampler2DMS:
+                return 2;
             case EbtISampler3D:
                 return 3;
             case EbtISamplerCube:
@@ -249,6 +253,8 @@ int GetHLSLCoordCount(const TextureFunctionHLSL::TextureFunction &textureFunctio
                 return 3;
             case EbtUSampler2D:
                 return 2;
+            case EbtUSampler2DMS:
+                return 2;
             case EbtUSampler3D:
                 return 3;
             case EbtUSamplerCube:
@@ -1086,17 +1092,20 @@ const char *TextureFunctionHLSL::TextureFunction::getReturnType() const
         switch (sampler)
         {
             case EbtSampler2D:
+            case EbtSampler2DMS:
             case EbtSampler3D:
             case EbtSamplerCube:
             case EbtSampler2DArray:
             case EbtSamplerExternalOES:
                 return "float4";
             case EbtISampler2D:
+            case EbtISampler2DMS:
             case EbtISampler3D:
             case EbtISamplerCube:
             case EbtISampler2DArray:
                 return "int4";
             case EbtUSampler2D:
+            case EbtUSampler2DMS:
             case EbtUSampler3D:
             case EbtUSamplerCube:
             case EbtUSampler2DArray:

src/libANGLE/renderer/TextureImpl.cpp

@@ -54,4 +54,5 @@ gl::Error TextureImpl::copyCompressedTexture(const gl::Context *context, const g
     UNREACHABLE();
     return gl::InternalError() << "CHROMIUM_copy_compressed_texture exposed but not implemented.";
 }
+
 }  // namespace rx

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -15,6 +15,7 @@
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/ImageIndex.h"
 #include "libANGLE/ResourceManager.h"
 #include "libANGLE/State.h"
 #include "libANGLE/VertexArray.h"
@@ -27,6 +28,7 @@
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/SamplerD3D.h"
+#include "libANGLE/renderer/d3d/TextureD3D.h"
 
 namespace rx
 {
@@ -229,7 +231,14 @@ gl::Texture *RendererD3D::getIncompleteTexture(const gl::Context *context, GLenu
         // Skip the API layer to avoid needing to pass the Context and mess with dirty bits.
         gl::Texture *t =
             new gl::Texture(implFactory, std::numeric_limits<GLuint>::max(), createType);
-        t->setStorage(nullptr, createType, 1, GL_RGBA8, colorSize);
+        if (createType == GL_TEXTURE_2D_MULTISAMPLE)
+        {
+            t->setStorageMultisample(nullptr, createType, 1, GL_RGBA8, colorSize, true);
+        }
+        else
+        {
+            t->setStorage(nullptr, createType, 1, GL_RGBA8, colorSize);
+        }
         if (type == GL_TEXTURE_CUBE_MAP)
         {
             for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
@@ -239,6 +248,12 @@ gl::Texture *RendererD3D::getIncompleteTexture(const gl::Context *context, GLenu
                                                     GL_UNSIGNED_BYTE, unpack, color);
             }
         }
+        else if (type == GL_TEXTURE_2D_MULTISAMPLE)
+        {
+            gl::ColorF clearValue(0, 0, 0, 1);
+            gl::ImageIndex index = gl::ImageIndex::Make2DMultisample();
+            GetImplAs<TextureD3D>(t)->clearLevel(context, index, clearValue);
+        }
         else
         {
             t->getImplementation()->setSubImage(nullptr, createType, 0, area, GL_RGBA8,

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -11,6 +11,7 @@
 
 #include <array>
 
+#include "common/Color.h"
 #include "common/MemoryBuffer.h"
 #include "common/debug.h"
 #include "libANGLE/ContextState.h"
@@ -268,6 +269,12 @@ class RendererD3D : public BufferFactoryD3D
     virtual TextureStorage *createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly) = 0;
     virtual TextureStorage *createTextureStorage3D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
     virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
+    virtual TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              int levels,
+                                                              int samples,
+                                                              GLboolean fixedSampleLocations) = 0;
 
     // Buffer-to-texture and Texture-to-buffer copies
     virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const = 0;
@@ -300,6 +307,9 @@ class RendererD3D : public BufferFactoryD3D
                                     size_t rangeStart,
                                     size_t rangeEnd) = 0;
 
+    virtual gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                        const gl::ColorF &clearValues) = 0;
+
     virtual egl::Error getEGLDevice(DeviceImpl **device) = 0;
 
     bool presentPathFastEnabled() const { return mPresentPathFastEnabled; }

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -9,6 +9,7 @@
 #ifndef LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
 #define LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
 
+#include "common/Color.h"
 #include "libANGLE/Constants.h"
 #include "libANGLE/Stream.h"
 #include "libANGLE/angletypes.h"
@@ -55,6 +56,12 @@ class TextureD3D : public TextureImpl
     GLint getBaseLevelHeight() const;
     GLenum getBaseLevelInternalFormat() const;
 
+    gl::Error setStorage(const gl::Context *context,
+                         GLenum target,
+                         size_t levels,
+                         GLenum internalFormat,
+                         const gl::Extents &size);
+
     gl::Error setStorageMultisample(const gl::Context *context,
                                     GLenum target,
                                     GLsizei samples,
@@ -93,6 +100,10 @@ class TextureD3D : public TextureImpl
 
     void syncState(const gl::Texture::DirtyBits &dirtyBits) override;
 
+    gl::Error clearLevel(const gl::Context *context,
+                         const gl::ImageIndex &index,
+                         const gl::ColorF &clearValues);
+
   protected:
     gl::Error setImageImpl(const gl::Context *context,
                            const gl::ImageIndex &index,
@@ -287,13 +298,6 @@ class TextureD3D_2D : public TextureD3D
     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
     bool isValidIndex(const gl::ImageIndex &index) const override;
 
-    gl::Error setStorageMultisample(const gl::Context *context,
-                                    GLenum target,
-                                    GLsizei samples,
-                                    GLint internalFormat,
-                                    const gl::Extents &size,
-                                    GLboolean fixedSampleLocations) override;
-
   protected:
     void markAllImagesDirty() override;
 
@@ -846,16 +850,12 @@ class TextureD3D_2DMultisample : public TextureD3D
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error setStorage(const gl::Context *context,
-                         GLenum target,
-                         size_t levels,
-                         GLenum internalFormat,
-                         const gl::Extents &size) override;
-
-    gl::Error setImageExternal(const gl::Context *context,
-                               GLenum target,
-                               egl::Stream *stream,
-                               const egl::Stream::GLTextureDescription &desc) override;
+    gl::Error setStorageMultisample(const gl::Context *context,
+                                    GLenum target,
+                                    GLsizei samples,
+                                    GLint internalFormat,
+                                    const gl::Extents &size,
+                                    GLboolean fixedSampleLocations) override;
 
     gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
     gl::Error releaseTexImage(const gl::Context *context) override;

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -3955,6 +3955,17 @@ TextureStorage *Renderer11::createTextureStorage2DArray(GLenum internalformat,
                                         levels);
 }
 
+TextureStorage *Renderer11::createTextureStorage2DMultisample(GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              int levels,
+                                                              int samples,
+                                                              GLboolean fixedSampleLocations)
+{
+    return new TextureStorage11_2DMultisample(this, internalformat, width, height, levels, samples,
+                                              fixedSampleLocations);
+}
+
 gl::Error Renderer11::readFromAttachment(const gl::Context *context,
                                          const gl::FramebufferAttachment &srcAttachment,
                                          const gl::Rectangle &sourceArea,
@@ -4954,4 +4965,15 @@ gl::Error Renderer11::getSamplerState(const gl::SamplerState &samplerState,
     return mStateCache.getSamplerState(this, samplerState, outSamplerState);
 }
 
+gl::Error Renderer11::clearRenderTarget(RenderTargetD3D *renderTarget,
+                                        const gl::ColorF &clearValues)
+{
+    RenderTarget11 *renderTarget11     = GetAs<RenderTarget11>(renderTarget);
+    const d3d11::RenderTargetView &rtv = renderTarget11->getRenderTargetView();
+
+    mDeviceContext->ClearRenderTargetView(rtv.get(), &clearValues.red);
+
+    return gl::NoError();
+}
+
 }  // namespace rx

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -308,6 +308,12 @@ class Renderer11 : public RendererD3D
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 int levels) override;
+    TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      int levels,
+                                                      int samples,
+                                                      GLboolean fixedSampleLocations) override;
 
     VertexBuffer *createVertexBuffer() override;
     IndexBuffer *createIndexBuffer() override;
@@ -472,6 +478,9 @@ class Renderer11 : public RendererD3D
                               const D3D11_SUBRESOURCE_DATA *initData,
                               TextureHelper11 *textureOut);
 
+    gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                const gl::ColorF &clearValues) override;
+
   protected:
     gl::Error clearTextures(const gl::Context *context,
                             gl::SamplerType samplerType,

src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp

@@ -2907,4 +2907,213 @@ gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_2DArray::ensur
     return DropStencil::CREATED;
 }
 
+TextureStorage11_2DMultisample::TextureStorage11_2DMultisample(Renderer11 *renderer,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               int levels,
+                                                               int samples,
+                                                               GLboolean fixedSampleLocations)
+    : TextureStorage11(
+          renderer,
+          GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), true),
+          GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), true, levels),
+          internalformat),
+      mTexture(),
+      mRenderTarget(nullptr)
+{
+    // adjust size if needed for compressed textures
+    d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel);
+
+    mMipLevels            = 1;
+    mTextureWidth         = width;
+    mTextureHeight        = height;
+    mTextureDepth         = 1;
+    mSamples              = samples;
+    mFixedSampleLocations = fixedSampleLocations;
+}
+
+gl::Error TextureStorage11_2DMultisample::onDestroy(const gl::Context *context)
+{
+    mRenderTarget.reset();
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_2DMultisample::~TextureStorage11_2DMultisample()
+{
+}
+
+gl::Error TextureStorage11_2DMultisample::copyToStorage(const gl::Context *context,
+                                                        TextureStorage *destStorage)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "copyToStorage is unimplemented";
+}
+
+void TextureStorage11_2DMultisample::associateImage(Image11 *image, const gl::ImageIndex &index)
+{
+}
+
+void TextureStorage11_2DMultisample::verifyAssociatedImageValid(const gl::ImageIndex &index,
+                                                                Image11 *expectedImage)
+{
+}
+
+void TextureStorage11_2DMultisample::disassociateImage(const gl::ImageIndex &index,
+                                                       Image11 *expectedImage)
+{
+}
+
+gl::Error TextureStorage11_2DMultisample::releaseAssociatedImage(const gl::Context *context,
+                                                                 const gl::ImageIndex &index,
+                                                                 Image11 *incomingImage)
+{
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getResource(const gl::Context *context,
+                                                      const TextureHelper11 **outResource)
+{
+    ANGLE_TRY(ensureTextureExists(1));
+
+    *outResource = &mTexture;
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::ensureTextureExists(int mipLevels)
+{
+    // For Multisampled textures, mipLevels always equals 1.
+    ASSERT(mipLevels == 1);
+
+    // if the width or height is not positive this should be treated as an incomplete texture
+    // we handle that here by skipping the d3d texture creation
+    if (!mTexture.valid() && mTextureWidth > 0 && mTextureHeight > 0)
+    {
+        D3D11_TEXTURE2D_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.Width          = mTextureWidth;  // Compressed texture size constraints?
+        desc.Height         = mTextureHeight;
+        desc.MipLevels      = mipLevels;
+        desc.ArraySize      = 1;
+        desc.Format         = mFormatInfo.texFormat;
+        desc.Usage          = D3D11_USAGE_DEFAULT;
+        desc.BindFlags      = getBindFlags();
+        desc.CPUAccessFlags = 0;
+        desc.MiscFlags      = getMiscFlags();
+
+        const gl::TextureCaps &textureCaps =
+            mRenderer->getNativeTextureCaps().get(mFormatInfo.internalFormat);
+        GLuint supportedSamples = textureCaps.getNearestSamples(mSamples);
+        desc.SampleDesc.Count   = (supportedSamples == 0) ? 1 : supportedSamples;
+        desc.SampleDesc.Quality = 0;
+
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
+        mTexture.setDebugName("TexStorage2DMS.Texture");
+    }
+
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *context,
+                                                          const gl::ImageIndex &index,
+                                                          RenderTargetD3D **outRT)
+{
+    ASSERT(!index.hasLayer());
+
+    const int level = index.mipIndex;
+    ASSERT(level == 0);
+
+    ASSERT(outRT);
+    if (mRenderTarget)
+    {
+        *outRT = mRenderTarget.get();
+        return gl::NoError();
+    }
+
+    const TextureHelper11 *texture = nullptr;
+    ANGLE_TRY(getResource(context, &texture));
+
+    const d3d11::SharedSRV *srv = nullptr;
+    ANGLE_TRY(getSRVLevel(context, level, false, &srv));
+
+    const d3d11::SharedSRV *blitSRV = nullptr;
+    ANGLE_TRY(getSRVLevel(context, level, true, &blitSRV));
+
+    if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN)
+    {
+        D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
+        rtvDesc.Format        = mFormatInfo.rtvFormat;
+        rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
+
+        d3d11::RenderTargetView rtv;
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
+
+        mRenderTarget.reset(new TextureRenderTarget11(
+            std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+            getLevelWidth(level), getLevelHeight(level), 1, mSamples));
+
+        *outRT = mRenderTarget.get();
+        return gl::NoError();
+    }
+
+    ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN);
+
+    D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
+    dsvDesc.Format        = mFormatInfo.dsvFormat;
+    dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
+    dsvDesc.Flags         = 0;
+
+    d3d11::DepthStencilView dsv;
+    ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
+
+    mRenderTarget.reset(new TextureRenderTarget11(
+        std::move(dsv), *texture, *srv, mFormatInfo.internalFormat, getFormatSet(),
+        getLevelWidth(level), getLevelHeight(level), 1, mSamples));
+
+    *outRT = mRenderTarget.get();
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::createSRV(const gl::Context *context,
+                                                    int baseLevel,
+                                                    int mipLevels,
+                                                    DXGI_FORMAT format,
+                                                    const TextureHelper11 &texture,
+                                                    d3d11::SharedSRV *outSRV) const
+{
+    ASSERT(outSRV);
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+    srvDesc.Format        = format;
+    srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
+
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
+    outSRV->setDebugName("TexStorage2DMS.SRV");
+
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getSwizzleTexture(const TextureHelper11 **outTexture)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "getSwizzleTexture is unimplemented.";
+}
+
+gl::Error TextureStorage11_2DMultisample::getSwizzleRenderTarget(
+    int mipLevel,
+    const d3d11::RenderTargetView **outRTV)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "getSwizzleRenderTarget is unimplemented.";
+}
+
+gl::ErrorOrResult<TextureStorage11::DropStencil>
+TextureStorage11_2DMultisample::ensureDropStencilTexture(const gl::Context *context)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "Drop stencil texture not implemented.";
+}
+
 }  // namespace rx

src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h

@@ -509,6 +509,56 @@ class TextureStorage11_2DArray : public TextureStorage11
     ImageMap mAssociatedImages;
 };
 
+class TextureStorage11_2DMultisample : public TextureStorage11
+{
+  public:
+    TextureStorage11_2DMultisample(Renderer11 *renderer,
+                                   GLenum internalformat,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   int levels,
+                                   int samples,
+                                   GLboolean fixedSampleLocations);
+    ~TextureStorage11_2DMultisample() override;
+
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
+
+    void associateImage(Image11 *image, const gl::ImageIndex &index) override;
+    void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
+    void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
+
+  protected:
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
+    gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
+
+    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context) override;
+
+    gl::Error ensureTextureExists(int mipLevels);
+
+  private:
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
+                        int mipLevels,
+                        DXGI_FORMAT format,
+                        const TextureHelper11 &texture,
+                        d3d11::SharedSRV *outSRV) const override;
+
+    TextureHelper11 mTexture;
+    std::unique_ptr<RenderTarget11> mRenderTarget;
+
+    unsigned int mSamples;
+    GLboolean mFixedSampleLocations;
+};
 }
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp

@@ -1294,6 +1294,7 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons
 
     // Multisample limits
     caps->maxSamples = maxSamples;
+    caps->maxColorTextureSamples = maxSamples;
 
     // GL extension support
     extensions->setTextureExtensionSupport(*textureCapsMap);

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -2997,6 +2997,19 @@ TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat,
     return nullptr;
 }
 
+TextureStorage *Renderer9::createTextureStorage2DMultisample(GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             int levels,
+                                                             int samples,
+                                                             GLboolean fixedSampleLocations)
+{
+    // 2D multisampled textures are not supported by the D3D9 backend.
+    UNREACHABLE();
+
+    return NULL;
+}
+
 bool Renderer9::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;
@@ -3214,4 +3227,10 @@ gl::Error Renderer9::applyComputeUniforms(const ProgramD3D &programD3D,
     return gl::InternalError() << "Compute shader is not implemented on D3D9";
 }
 
+gl::Error Renderer9::clearRenderTarget(RenderTargetD3D *renderTarget, const gl::ColorF &clearValues)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "clearRenderTarget is not implemented on D3D9";
+}
+
 }  // namespace rx

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -316,6 +316,13 @@ class Renderer9 : public RendererD3D
                                                 GLsizei depth,
                                                 int levels) override;
 
+    TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      int levels,
+                                                      int samples,
+                                                      GLboolean fixedSampleLocations) override;
+
     // Buffer creation
     VertexBuffer *createVertexBuffer() override;
     IndexBuffer *createIndexBuffer() override;
@@ -388,6 +395,9 @@ class Renderer9 : public RendererD3D
     gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
                                    const std::vector<D3DUniform *> &uniformArray) override;
 
+    gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                const gl::ColorF &clearValues) override;
+
   protected:
     gl::Error clearTextures(const gl::Context *context,
                             gl::SamplerType samplerType,

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -92,7 +92,8 @@
 1951 D3D11 : dEQP-GLES31.functional.state_query.indexed.shader_storage_buffer_* = FAIL
 1442 D3D11 : dEQP-GLES31.functional.state_query.internal_format.renderbuffer.* = FAIL
 1679 D3D11 : dEQP-GLES31.functional.state_query.texture_level.texture_2d_multisample.* = FAIL
-1442 D3D11 : dEQP-GLES31.functional.texture.multisample.* = FAIL
+1442 D3D11 : dEQP-GLES31.functional.texture.multisample.negative.texture* = FAIL
+1442 D3D11 : dEQP-GLES31.functional.texture.multisample.samples* = FAIL
 1442 D3D11 : dEQP-GLES31.functional.state_query.framebuffer_default.framebuffer_default_width_get_framebuffer_parameteriv = FAIL
 1442 D3D11 : dEQP-GLES31.functional.state_query.framebuffer_default.framebuffer_default_height_get_framebuffer_parameteriv = FAIL
 1442 D3D11 : dEQP-GLES31.functional.state_query.framebuffer_default.framebuffer_default_samples_get_framebuffer_parameteriv = FAIL

src/tests/gl_tests/TextureMultisampleTest.cpp

@@ -141,9 +141,10 @@ TEST_P(TextureMultisampleTestES31, ValidateTextureStorageMultisampleParameters)
 }
 
 ANGLE_INSTANTIATE_TEST(TextureMultisampleTest,
+                       ES31_D3D11(),
                        ES3_OPENGL(),
                        ES3_OPENGLES(),
                        ES31_OPENGL(),
                        ES31_OPENGLES());
-ANGLE_INSTANTIATE_TEST(TextureMultisampleTestES31, ES31_OPENGL(), ES31_OPENGLES());
+ANGLE_INSTANTIATE_TEST(TextureMultisampleTestES31, ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES());
 }