diff options
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/renderer/d3d')
355 files changed, 90483 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.cpp new file mode 100644 index 0000000000..464bd6d4a8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.cpp @@ -0,0 +1,191 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// BufferD3D.cpp Defines common functionality between the Buffer9 and Buffer11 classes. + +#include "libANGLE/renderer/d3d/BufferD3D.h" + +#include "common/mathutil.h" +#include "common/utilities.h" +#include "libANGLE/renderer/d3d/IndexBuffer.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/VertexBuffer.h" + +namespace rx +{ + +unsigned int BufferD3D::mNextSerial = 1; + +BufferD3D::BufferD3D(const gl::BufferState &state, BufferFactoryD3D *factory) + : BufferImpl(state), + mFactory(factory), + mStaticIndexBuffer(nullptr), + mStaticBufferCacheTotalSize(0), + mStaticVertexBufferOutOfDate(false), + mUnmodifiedDataUse(0), + mUsage(D3DBufferUsage::STATIC) +{ + updateSerial(); +} + +BufferD3D::~BufferD3D() +{ + SafeDelete(mStaticIndexBuffer); +} + +void BufferD3D::emptyStaticBufferCache() +{ + mStaticVertexBuffers.clear(); + mStaticBufferCacheTotalSize = 0; +} + +void BufferD3D::updateSerial() +{ + mSerial = mNextSerial++; +} + +void BufferD3D::updateD3DBufferUsage(const gl::Context *context, gl::BufferUsage usage) +{ + switch (usage) + { + case gl::BufferUsage::StaticCopy: + case gl::BufferUsage::StaticDraw: + case gl::BufferUsage::StaticRead: + case gl::BufferUsage::DynamicCopy: + case gl::BufferUsage::DynamicRead: + case gl::BufferUsage::StreamCopy: + case gl::BufferUsage::StreamRead: + mUsage = D3DBufferUsage::STATIC; + initializeStaticData(context); + break; + + case gl::BufferUsage::DynamicDraw: + case gl::BufferUsage::StreamDraw: + mUsage = D3DBufferUsage::DYNAMIC; + break; + default: + UNREACHABLE(); + } +} + +void BufferD3D::initializeStaticData(const gl::Context *context) +{ + if (mStaticVertexBuffers.empty()) + { + StaticVertexBufferInterface *newStaticBuffer = new StaticVertexBufferInterface(mFactory); + mStaticVertexBuffers.push_back( + std::unique_ptr<StaticVertexBufferInterface>(newStaticBuffer)); + } + if (!mStaticIndexBuffer) + { + mStaticIndexBuffer = new StaticIndexBufferInterface(mFactory); + } +} + +StaticIndexBufferInterface *BufferD3D::getStaticIndexBuffer() +{ + return mStaticIndexBuffer; +} + +StaticVertexBufferInterface *BufferD3D::getStaticVertexBuffer(const gl::VertexAttribute &attribute, + const gl::VertexBinding &binding) +{ + if (mStaticVertexBuffers.empty()) + { + // Early out if there aren't any static buffers at all + return nullptr; + } + + // Early out, the attribute can be added to mStaticVertexBuffer. + if (mStaticVertexBuffers.size() == 1 && mStaticVertexBuffers[0]->empty()) + { + return mStaticVertexBuffers[0].get(); + } + + // Cache size limiting: track the total allocated buffer sizes. + size_t currentTotalSize = 0; + + // At this point, see if any of the existing static buffers contains the attribute data + // If there is a cached static buffer that already contains the attribute, then return it + for (const auto &staticBuffer : mStaticVertexBuffers) + { + if (staticBuffer->matchesAttribute(attribute, binding)) + { + return staticBuffer.get(); + } + + currentTotalSize += staticBuffer->getBufferSize(); + } + + // Cache size limiting: Clean-up threshold is four times the base buffer size, with a minimum. + ASSERT(getSize() < std::numeric_limits<size_t>::max() / 4u); + size_t sizeThreshold = std::max(getSize() * 4u, static_cast<size_t>(0x1000u)); + + // If we're past the threshold, clear the buffer cache. Note that this will release buffers + // that are currenly bound, and in an edge case can even translate the same attribute twice + // in the same draw call. It will not delete currently bound buffers, however, because they + // are ref counted. + if (currentTotalSize > sizeThreshold) + { + emptyStaticBufferCache(); + } + + // At this point, we must create a new static buffer for the attribute data. + StaticVertexBufferInterface *newStaticBuffer = new StaticVertexBufferInterface(mFactory); + newStaticBuffer->setAttribute(attribute, binding); + mStaticVertexBuffers.push_back(std::unique_ptr<StaticVertexBufferInterface>(newStaticBuffer)); + return newStaticBuffer; +} + +void BufferD3D::invalidateStaticData(const gl::Context *context) +{ + emptyStaticBufferCache(); + + if (mStaticIndexBuffer && mStaticIndexBuffer->getBufferSize() != 0) + { + SafeDelete(mStaticIndexBuffer); + } + + // If the buffer was created with a static usage then we recreate the static + // buffers so that they are populated the next time we use this buffer. + if (mUsage == D3DBufferUsage::STATIC) + { + initializeStaticData(context); + } + + mUnmodifiedDataUse = 0; +} + +// Creates static buffers if sufficient used data has been left unmodified +void BufferD3D::promoteStaticUsage(const gl::Context *context, size_t dataSize) +{ + if (mUsage == D3DBufferUsage::DYNAMIC) + { + // Note: This is not a safe math operation. 'dataSize' can come from the app. + mUnmodifiedDataUse += dataSize; + + if (mUnmodifiedDataUse > 3 * getSize()) + { + updateD3DBufferUsage(context, gl::BufferUsage::StaticDraw); + } + } +} + +angle::Result BufferD3D::getIndexRange(const gl::Context *context, + gl::DrawElementsType type, + size_t offset, + size_t count, + bool primitiveRestartEnabled, + gl::IndexRange *outRange) +{ + const uint8_t *data = nullptr; + ANGLE_TRY(getData(context, &data)); + + *outRange = gl::ComputeIndexRange(type, data + offset, count, primitiveRestartEnabled); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.h new file mode 100644 index 0000000000..19ea78c6eb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/BufferD3D.h @@ -0,0 +1,89 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// BufferD3D.h: Defines the rx::BufferD3D class, an implementation of BufferImpl. + +#ifndef LIBANGLE_RENDERER_D3D_BUFFERD3D_H_ +#define LIBANGLE_RENDERER_D3D_BUFFERD3D_H_ + +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/BufferImpl.h" + +#include <stdint.h> +#include <vector> + +namespace gl +{ +struct VertexAttribute; +class VertexBinding; +} // namespace gl + +namespace rx +{ +class BufferFactoryD3D; +class StaticIndexBufferInterface; +class StaticVertexBufferInterface; + +enum class D3DBufferUsage +{ + STATIC, + DYNAMIC, +}; + +class BufferD3D : public BufferImpl +{ + public: + BufferD3D(const gl::BufferState &state, BufferFactoryD3D *factory); + ~BufferD3D() override; + + unsigned int getSerial() const { return mSerial; } + + virtual size_t getSize() const = 0; + virtual bool supportsDirectBinding() const = 0; + virtual angle::Result markTransformFeedbackUsage(const gl::Context *context) = 0; + virtual angle::Result getData(const gl::Context *context, const uint8_t **outData) = 0; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + StaticVertexBufferInterface *getStaticVertexBuffer(const gl::VertexAttribute &attribute, + const gl::VertexBinding &binding); + StaticIndexBufferInterface *getStaticIndexBuffer(); + + virtual void initializeStaticData(const gl::Context *context); + virtual void invalidateStaticData(const gl::Context *context); + + void promoteStaticUsage(const gl::Context *context, size_t dataSize); + + angle::Result getIndexRange(const gl::Context *context, + gl::DrawElementsType type, + size_t offset, + size_t count, + bool primitiveRestartEnabled, + gl::IndexRange *outRange) override; + + BufferFactoryD3D *getFactory() const { return mFactory; } + D3DBufferUsage getUsage() const { return mUsage; } + + protected: + void updateSerial(); + void updateD3DBufferUsage(const gl::Context *context, gl::BufferUsage usage); + void emptyStaticBufferCache(); + + BufferFactoryD3D *mFactory; + unsigned int mSerial; + static unsigned int mNextSerial; + + std::vector<std::unique_ptr<StaticVertexBufferInterface>> mStaticVertexBuffers; + StaticIndexBufferInterface *mStaticIndexBuffer; + unsigned int mStaticBufferCacheTotalSize; + unsigned int mStaticVertexBufferOutOfDate; + size_t mUnmodifiedDataUse; + D3DBufferUsage mUsage; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_BUFFERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.cpp new file mode 100644 index 0000000000..4656cf4d80 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.cpp @@ -0,0 +1,24 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// CompilerD3D: +// Implementation of the D3D compiler methods. +// + +#include "libANGLE/renderer/d3d/CompilerD3D.h" + +namespace rx +{ + +CompilerD3D::CompilerD3D(ShShaderOutput translatorOutputType) + : mTranslatorOutputType(translatorOutputType) +{} + +ShShaderOutput CompilerD3D::getTranslatorOutputType() const +{ + return mTranslatorOutputType; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.h new file mode 100644 index 0000000000..3e1d01a0b9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/CompilerD3D.h @@ -0,0 +1,32 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// CompilerD3D.h: Defines the rx::CompilerD3D class, an implementation of rx::CompilerImpl. + +#ifndef LIBANGLE_RENDERER_COMPILERD3D_H_ +#define LIBANGLE_RENDERER_COMPILERD3D_H_ + +#include "libANGLE/renderer/CompilerImpl.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ + +class CompilerD3D : public CompilerImpl +{ + public: + CompilerD3D(ShShaderOutput translatorOutputType); + ~CompilerD3D() override {} + + ShShaderOutput getTranslatorOutputType() const override; + + private: + ShShaderOutput mTranslatorOutputType; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_COMPILERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ContextD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ContextD3D.h new file mode 100644 index 0000000000..d563672e67 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ContextD3D.h @@ -0,0 +1,24 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ContextD3D: Shared common class for Context9 and Context11. + +#ifndef LIBANGLE_RENDERER_CONTEXTD3D_H_ +#define LIBANGLE_RENDERER_CONTEXTD3D_H_ + +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ +class ContextD3D : public ContextImpl, public d3d::Context +{ + public: + ContextD3D(const gl::State &state, gl::ErrorSet *errorSet) : ContextImpl(state, errorSet) {} + ~ContextD3D() override {} +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_CONTEXTD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.cpp new file mode 100644 index 0000000000..79dfb094e3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.cpp @@ -0,0 +1,84 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// DeviceD3D.cpp: D3D implementation of egl::Device + +#include "libANGLE/renderer/d3d/DeviceD3D.h" + +#include "libANGLE/Device.h" +#include "libANGLE/Display.h" + +#include <EGL/eglext.h> + +namespace rx +{ + +DeviceD3D::DeviceD3D(GLint deviceType, void *nativeDevice) + : mDevice(nativeDevice), mDeviceType(deviceType), mIsInitialized(false) +{} + +DeviceD3D::~DeviceD3D() +{ +#if defined(ANGLE_ENABLE_D3D11) + if (mIsInitialized && mDeviceType == EGL_D3D11_DEVICE_ANGLE) + { + // DeviceD3D holds a ref to an externally-sourced D3D11 device. We must release it. + ID3D11Device *device = static_cast<ID3D11Device *>(mDevice); + device->Release(); + } +#endif +} + +egl::Error DeviceD3D::getAttribute(const egl::Display *display, EGLint attribute, void **outValue) +{ + ASSERT(mIsInitialized); + ANGLE_UNUSED_VARIABLE(display); + // Validated at higher levels. + ASSERT(getType() == attribute); + *outValue = mDevice; + return egl::NoError(); +} + +egl::Error DeviceD3D::initialize() +{ + ASSERT(!mIsInitialized); + +#if defined(ANGLE_ENABLE_D3D11) + if (mDeviceType == EGL_D3D11_DEVICE_ANGLE) + { + // Validate the device + IUnknown *iunknown = static_cast<IUnknown *>(mDevice); + + ID3D11Device *d3dDevice = nullptr; + HRESULT hr = + iunknown->QueryInterface(__uuidof(ID3D11Device), reinterpret_cast<void **>(&d3dDevice)); + if (FAILED(hr)) + { + return egl::EglBadAttribute() << "Invalid D3D device passed into EGLDeviceEXT"; + } + + // The QI to ID3D11Device adds a ref to the D3D11 device. + // Deliberately don't release the ref here, so that the DeviceD3D holds a ref to the + // D3D11 device. + } +#endif + + mIsInitialized = true; + + return egl::NoError(); +} + +EGLint DeviceD3D::getType() +{ + return mDeviceType; +} + +void DeviceD3D::generateExtensions(egl::DeviceExtensions *outExtensions) const +{ + outExtensions->deviceD3D = true; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.h new file mode 100644 index 0000000000..c169eb7de5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DeviceD3D.h @@ -0,0 +1,39 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// DeviceD3D.h: D3D implementation of egl::Device + +#ifndef LIBANGLE_RENDERER_D3D_DEVICED3D_H_ +#define LIBANGLE_RENDERER_D3D_DEVICED3D_H_ + +#include "libANGLE/Device.h" +#include "libANGLE/renderer/DeviceImpl.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ +class DeviceD3D : public DeviceImpl +{ + public: + DeviceD3D(EGLint deviceType, void *nativeDevice); + ~DeviceD3D() override; + + egl::Error initialize() override; + egl::Error getAttribute(const egl::Display *display, + EGLint attribute, + void **outValue) override; + EGLint getType() override; + void generateExtensions(egl::DeviceExtensions *outExtensions) const override; + + private: + void *mDevice; + EGLint mDeviceType; + bool mIsInitialized; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_DEVICED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.cpp new file mode 100644 index 0000000000..35216fd4d2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.cpp @@ -0,0 +1,462 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// DisplayD3D.cpp: D3D implementation of egl::Display + +#include "libANGLE/renderer/d3d/DisplayD3D.h" + +#include <EGL/eglext.h> + +#include "libANGLE/Config.h" +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/Surface.h" +#include "libANGLE/Thread.h" +#include "libANGLE/histogram_macros.h" +#include "libANGLE/renderer/d3d/DeviceD3D.h" +#include "libANGLE/renderer/d3d/EGLImageD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/SurfaceD3D.h" +#include "libANGLE/renderer/d3d/SwapChainD3D.h" + +#if !defined(ANGLE_DEFAULT_D3D11) +// Enables use of the Direct3D 11 API for a default display, when available +# define ANGLE_DEFAULT_D3D11 1 +#endif + +namespace rx +{ + +using CreateRendererD3DFunction = RendererD3D *(*)(egl::Display *); + +egl::Error CreateRendererD3D(egl::Display *display, RendererD3D **outRenderer) +{ + ASSERT(outRenderer != nullptr); + + std::vector<CreateRendererD3DFunction> rendererCreationFunctions; + + if (display->getPlatform() == EGL_PLATFORM_ANGLE_ANGLE) + { + const auto &attribMap = display->getAttributeMap(); + EGLNativeDisplayType nativeDisplay = display->getNativeDisplayId(); + + EGLint requestedDisplayType = static_cast<EGLint>( + attribMap.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE)); + +#if defined(ANGLE_ENABLE_D3D11) + const auto addD3D11 = nativeDisplay == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE || + nativeDisplay == EGL_D3D11_ONLY_DISPLAY_ANGLE || + requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE; +#endif + +#if defined(ANGLE_ENABLE_D3D9) + const auto addD3D9 = nativeDisplay == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE || + requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE; +#endif + +#if ANGLE_DEFAULT_D3D11 +# if defined(ANGLE_ENABLE_D3D11) + if (addD3D11) + { + rendererCreationFunctions.push_back(CreateRenderer11); + } +# endif + +# if defined(ANGLE_ENABLE_D3D9) + if (addD3D9) + { + rendererCreationFunctions.push_back(CreateRenderer9); + } +# endif +#else +# if defined(ANGLE_ENABLE_D3D9) + if (addD3D9) + { + rendererCreationFunctions.push_back(CreateRenderer9); + } +# endif + +# if defined(ANGLE_ENABLE_D3D11) + if (addD3D11) + { + rendererCreationFunctions.push_back(CreateRenderer11); + } +# endif +#endif + + if (nativeDisplay != EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE && + nativeDisplay != EGL_D3D11_ONLY_DISPLAY_ANGLE && + requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE) + { + // The default display is requested, try the D3D9 and D3D11 renderers, order them using + // the definition of ANGLE_DEFAULT_D3D11 +#if ANGLE_DEFAULT_D3D11 +# if defined(ANGLE_ENABLE_D3D11) + rendererCreationFunctions.push_back(CreateRenderer11); +# endif +# if defined(ANGLE_ENABLE_D3D9) + rendererCreationFunctions.push_back(CreateRenderer9); +# endif +#else +# if defined(ANGLE_ENABLE_D3D9) + rendererCreationFunctions.push_back(CreateRenderer9); +# endif +# if defined(ANGLE_ENABLE_D3D11) + rendererCreationFunctions.push_back(CreateRenderer11); +# endif +#endif + } + } + else if (display->getPlatform() == EGL_PLATFORM_DEVICE_EXT) + { +#if defined(ANGLE_ENABLE_D3D11) + if (display->getDevice()->getType() == EGL_D3D11_DEVICE_ANGLE) + { + rendererCreationFunctions.push_back(CreateRenderer11); + } +#endif + } + else + { + UNIMPLEMENTED(); + } + + for (size_t i = 0; i < rendererCreationFunctions.size(); i++) + { + RendererD3D *renderer = rendererCreationFunctions[i](display); + egl::Error result = renderer->initialize(); + +#if defined(ANGLE_ENABLE_D3D11) + if (renderer->getRendererClass() == RENDERER_D3D11) + { + ASSERT(result.getID() >= 0 && result.getID() < NUM_D3D11_INIT_ERRORS); + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3D11InitializeResult", result.getID(), + NUM_D3D11_INIT_ERRORS); + } +#endif + +#if defined(ANGLE_ENABLE_D3D9) + if (renderer->getRendererClass() == RENDERER_D3D9) + { + ASSERT(result.getID() >= 0 && result.getID() < NUM_D3D9_INIT_ERRORS); + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3D9InitializeResult", result.getID(), + NUM_D3D9_INIT_ERRORS); + } +#endif + + if (!result.isError()) + { + *outRenderer = renderer; + return result; + } + + // Failed to create the renderer, try the next + SafeDelete(renderer); + ERR() << "Failed to create D3D renderer: " << result.getMessage(); + } + + return egl::EglNotInitialized() << "No available renderers."; +} + +DisplayD3D::DisplayD3D(const egl::DisplayState &state) : DisplayImpl(state), mRenderer(nullptr) {} + +SurfaceImpl *DisplayD3D::createWindowSurface(const egl::SurfaceState &state, + EGLNativeWindowType window, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return new WindowSurfaceD3D(state, mRenderer, mDisplay, window, attribs); +} + +SurfaceImpl *DisplayD3D::createPbufferSurface(const egl::SurfaceState &state, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return new PbufferSurfaceD3D(state, mRenderer, mDisplay, 0, nullptr, attribs); +} + +SurfaceImpl *DisplayD3D::createPbufferFromClientBuffer(const egl::SurfaceState &state, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return new PbufferSurfaceD3D(state, mRenderer, mDisplay, buftype, clientBuffer, attribs); +} + +SurfaceImpl *DisplayD3D::createPixmapSurface(const egl::SurfaceState &state, + NativePixmapType nativePixmap, + const egl::AttributeMap &attribs) +{ + UNIMPLEMENTED(); + return nullptr; +} + +ImageImpl *DisplayD3D::createImage(const egl::ImageState &state, + const gl::Context *context, + EGLenum target, + const egl::AttributeMap &attribs) +{ + return new EGLImageD3D(state, target, attribs, mRenderer); +} + +DeviceImpl *DisplayD3D::createDevice() +{ + return mRenderer->createEGLDevice(); +} + +rx::ContextImpl *DisplayD3D::createContext(const gl::State &state, + gl::ErrorSet *errorSet, + const egl::Config *configuration, + const gl::Context *shareContext, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return mRenderer->createContext(state, errorSet); +} + +StreamProducerImpl *DisplayD3D::createStreamProducerD3DTexture( + egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return mRenderer->createStreamProducerD3DTexture(consumerType, attribs); +} + +ExternalImageSiblingImpl *DisplayD3D::createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) +{ + ASSERT(mRenderer != nullptr); + return mRenderer->createExternalImageSibling(context, target, buffer, attribs); +} + +ShareGroupImpl *DisplayD3D::createShareGroup() +{ + return new ShareGroupD3D(); +} + +egl::Error DisplayD3D::makeCurrent(egl::Display *display, + egl::Surface *drawSurface, + egl::Surface *readSurface, + gl::Context *context) +{ + // Ensure the appropriate global DebugAnnotator is used + ASSERT(mRenderer != nullptr); + mRenderer->setGlobalDebugAnnotator(); + + return egl::NoError(); +} + +egl::Error DisplayD3D::initialize(egl::Display *display) +{ + ASSERT(mRenderer == nullptr && display != nullptr); + mDisplay = display; + ANGLE_TRY(CreateRendererD3D(display, &mRenderer)); + return egl::NoError(); +} + +void DisplayD3D::terminate() +{ + SafeDelete(mRenderer); +} + +egl::ConfigSet DisplayD3D::generateConfigs() +{ + ASSERT(mRenderer != nullptr); + return mRenderer->generateConfigs(); +} + +bool DisplayD3D::testDeviceLost() +{ + ASSERT(mRenderer != nullptr); + return mRenderer->testDeviceLost(); +} + +egl::Error DisplayD3D::restoreLostDevice(const egl::Display *display) +{ + // Release surface resources to make the Reset() succeed + for (egl::Surface *surface : mState.surfaceSet) + { + ASSERT(!surface->getBoundTexture()); + SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface); + surfaceD3D->releaseSwapChain(); + } + + if (!mRenderer->resetDevice()) + { + return egl::EglBadAlloc(); + } + + // Restore any surfaces that may have been lost + for (const egl::Surface *surface : mState.surfaceSet) + { + SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface); + + ANGLE_TRY(surfaceD3D->resetSwapChain(display)); + } + + return egl::NoError(); +} + +bool DisplayD3D::isValidNativeWindow(EGLNativeWindowType window) const +{ + return mRenderer->isValidNativeWindow(window); +} + +egl::Error DisplayD3D::validateClientBuffer(const egl::Config *config, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) const +{ + switch (buftype) + { + case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE: + return mRenderer->validateShareHandle(config, static_cast<HANDLE>(clientBuffer), + attribs); + + case EGL_D3D_TEXTURE_ANGLE: + return mRenderer->getD3DTextureInfo(config, static_cast<IUnknown *>(clientBuffer), + attribs, nullptr, nullptr, nullptr, nullptr, + nullptr, nullptr); + + default: + return DisplayImpl::validateClientBuffer(config, buftype, clientBuffer, attribs); + } +} + +egl::Error DisplayD3D::validateImageClientBuffer(const gl::Context *context, + EGLenum target, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) const +{ + switch (target) + { + case EGL_D3D11_TEXTURE_ANGLE: + { + return mRenderer->getD3DTextureInfo(nullptr, static_cast<IUnknown *>(clientBuffer), + attribs, nullptr, nullptr, nullptr, nullptr, + nullptr, nullptr); + } + + default: + return DisplayImpl::validateImageClientBuffer(context, target, clientBuffer, attribs); + } +} + +void DisplayD3D::generateExtensions(egl::DisplayExtensions *outExtensions) const +{ + mRenderer->generateDisplayExtensions(outExtensions); +} + +std::string DisplayD3D::getRendererDescription() +{ + if (mRenderer) + { + return mRenderer->getRendererDescription(); + } + return std::string(); +} + +std::string DisplayD3D::getVendorString() +{ + if (mRenderer) + { + return mRenderer->getVendorString(); + } + return std::string(); +} + +std::string DisplayD3D::getVersionString(bool includeFullVersion) +{ + if (mRenderer) + { + return mRenderer->getVersionString(includeFullVersion); + } + return std::string(); +} + +void DisplayD3D::generateCaps(egl::Caps *outCaps) const +{ + // Display must be initialized to generate caps + ASSERT(mRenderer != nullptr); + + outCaps->textureNPOT = mRenderer->getNativeExtensions().textureNpotOES; +} + +egl::Error DisplayD3D::waitClient(const gl::Context *context) +{ + for (egl::Surface *surface : mState.surfaceSet) + { + SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface); + ANGLE_TRY(surfaceD3D->checkForOutOfDateSwapChain(this)); + } + + return egl::NoError(); +} + +egl::Error DisplayD3D::waitNative(const gl::Context *context, EGLint engine) +{ + egl::Surface *drawSurface = context->getCurrentDrawSurface(); + egl::Surface *readSurface = context->getCurrentReadSurface(); + + if (drawSurface != nullptr) + { + SurfaceD3D *drawSurfaceD3D = GetImplAs<SurfaceD3D>(drawSurface); + ANGLE_TRY(drawSurfaceD3D->checkForOutOfDateSwapChain(this)); + } + + if (readSurface != nullptr) + { + SurfaceD3D *readSurfaceD3D = GetImplAs<SurfaceD3D>(readSurface); + ANGLE_TRY(readSurfaceD3D->checkForOutOfDateSwapChain(this)); + } + + return egl::NoError(); +} + +gl::Version DisplayD3D::getMaxSupportedESVersion() const +{ + return mRenderer->getMaxSupportedESVersion(); +} + +gl::Version DisplayD3D::getMaxConformantESVersion() const +{ + return mRenderer->getMaxConformantESVersion(); +} + +Optional<gl::Version> DisplayD3D::getMaxSupportedDesktopVersion() const +{ + return Optional<gl::Version>::Invalid(); +} + +void DisplayD3D::handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) +{ + ASSERT(FAILED(hr)); + + std::stringstream errorStream; + errorStream << "Internal D3D11 error: " << gl::FmtHR(hr) << ", in " << file << ", " << function + << ":" << line << ". " << message; + + mStoredErrorString = errorStream.str(); +} + +void DisplayD3D::initializeFrontendFeatures(angle::FrontendFeatures *features) const +{ + mRenderer->initializeFrontendFeatures(features); +} + +void DisplayD3D::populateFeatureList(angle::FeatureList *features) +{ + mRenderer->getFeatures().populateFeatureList(features); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.h new file mode 100644 index 0000000000..890658f5ea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DisplayD3D.h @@ -0,0 +1,179 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// DisplayD3D.h: D3D implementation of egl::Display + +#ifndef LIBANGLE_RENDERER_D3D_DISPLAYD3D_H_ +#define LIBANGLE_RENDERER_D3D_DISPLAYD3D_H_ + +#include "libANGLE/Device.h" +#include "libANGLE/renderer/DisplayImpl.h" + +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ +class ShareGroupD3D : public ShareGroupImpl +{}; + +class DisplayD3D : public DisplayImpl, public d3d::Context +{ + public: + DisplayD3D(const egl::DisplayState &state); + + egl::Error initialize(egl::Display *display) override; + void terminate() override; + + // Surface creation + SurfaceImpl *createWindowSurface(const egl::SurfaceState &state, + EGLNativeWindowType window, + const egl::AttributeMap &attribs) override; + SurfaceImpl *createPbufferSurface(const egl::SurfaceState &state, + const egl::AttributeMap &attribs) override; + SurfaceImpl *createPbufferFromClientBuffer(const egl::SurfaceState &state, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) override; + SurfaceImpl *createPixmapSurface(const egl::SurfaceState &state, + NativePixmapType nativePixmap, + const egl::AttributeMap &attribs) override; + + ImageImpl *createImage(const egl::ImageState &state, + const gl::Context *context, + EGLenum target, + const egl::AttributeMap &attribs) override; + + ContextImpl *createContext(const gl::State &state, + gl::ErrorSet *errorSet, + const egl::Config *configuration, + const gl::Context *shareContext, + const egl::AttributeMap &attribs) override; + + StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) override; + + ExternalImageSiblingImpl *createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) override; + + ShareGroupImpl *createShareGroup() override; + + egl::Error makeCurrent(egl::Display *display, + egl::Surface *drawSurface, + egl::Surface *readSurface, + gl::Context *context) override; + + egl::ConfigSet generateConfigs() override; + + bool testDeviceLost() override; + egl::Error restoreLostDevice(const egl::Display *display) override; + + bool isValidNativeWindow(EGLNativeWindowType window) const override; + egl::Error validateClientBuffer(const egl::Config *configuration, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) const override; + egl::Error validateImageClientBuffer(const gl::Context *context, + EGLenum target, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) const override; + + DeviceImpl *createDevice() override; + + std::string getRendererDescription() override; + std::string getVendorString() override; + std::string getVersionString(bool includeFullVersion) override; + + egl::Error waitClient(const gl::Context *context) override; + egl::Error waitNative(const gl::Context *context, EGLint engine) override; + gl::Version getMaxSupportedESVersion() const override; + gl::Version getMaxConformantESVersion() const override; + Optional<gl::Version> getMaxSupportedDesktopVersion() const override; + + void handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) override; + + const std::string &getStoredErrorString() const { return mStoredErrorString; } + + void initializeFrontendFeatures(angle::FrontendFeatures *features) const override; + + void populateFeatureList(angle::FeatureList *features) override; + + private: + void generateExtensions(egl::DisplayExtensions *outExtensions) const override; + void generateCaps(egl::Caps *outCaps) const override; + + egl::Display *mDisplay; + + rx::RendererD3D *mRenderer; + std::string mStoredErrorString; +}; + +// Possible reasons RendererD3D initialize can fail +enum D3D11InitError +{ + // The renderer loaded successfully + D3D11_INIT_SUCCESS = 0, + // Failed to load the ANGLE & D3D compiler libraries + D3D11_INIT_COMPILER_ERROR, + // Failed to load a necessary DLL (non-compiler) + D3D11_INIT_MISSING_DEP, + // CreateDevice returned E_INVALIDARG + D3D11_INIT_CREATEDEVICE_INVALIDARG, + // CreateDevice failed with an error other than invalid arg + D3D11_INIT_CREATEDEVICE_ERROR, + // DXGI 1.2 required but not found + D3D11_INIT_INCOMPATIBLE_DXGI, + // Other initialization error + D3D11_INIT_OTHER_ERROR, + // CreateDevice returned E_FAIL + D3D11_INIT_CREATEDEVICE_FAIL, + // CreateDevice returned E_NOTIMPL + D3D11_INIT_CREATEDEVICE_NOTIMPL, + // CreateDevice returned E_OUTOFMEMORY + D3D11_INIT_CREATEDEVICE_OUTOFMEMORY, + // CreateDevice returned DXGI_ERROR_INVALID_CALL + D3D11_INIT_CREATEDEVICE_INVALIDCALL, + // CreateDevice returned DXGI_ERROR_SDK_COMPONENT_MISSING + D3D11_INIT_CREATEDEVICE_COMPONENTMISSING, + // CreateDevice returned DXGI_ERROR_WAS_STILL_DRAWING + D3D11_INIT_CREATEDEVICE_WASSTILLDRAWING, + // CreateDevice returned DXGI_ERROR_NOT_CURRENTLY_AVAILABLE + D3D11_INIT_CREATEDEVICE_NOTAVAILABLE, + // CreateDevice returned DXGI_ERROR_DEVICE_HUNG + D3D11_INIT_CREATEDEVICE_DEVICEHUNG, + // CreateDevice returned NULL + D3D11_INIT_CREATEDEVICE_NULL, + NUM_D3D11_INIT_ERRORS +}; + +enum D3D9InitError +{ + D3D9_INIT_SUCCESS = 0, + // Failed to load the D3D or ANGLE compiler + D3D9_INIT_COMPILER_ERROR, + // Failed to load a necessary DLL + D3D9_INIT_MISSING_DEP, + // Device creation error + D3D9_INIT_CREATE_DEVICE_ERROR, + // System does not meet minimum shader spec + D3D9_INIT_UNSUPPORTED_VERSION, + // System does not support stretchrect from textures + D3D9_INIT_UNSUPPORTED_STRETCHRECT, + // A call returned out of memory or device lost + D3D9_INIT_OUT_OF_MEMORY, + // Other unspecified error + D3D9_INIT_OTHER_ERROR, + NUM_D3D9_INIT_ERRORS +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_DISPLAYD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.cpp new file mode 100644 index 0000000000..b83c8bac6e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.cpp @@ -0,0 +1,1537 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DynamicHLSL.cpp: Implementation for link and run-time HLSL generation +// + +#include "libANGLE/renderer/d3d/DynamicHLSL.h" + +#include "common/string_utils.h" +#include "common/utilities.h" +#include "compiler/translator/blocklayoutHLSL.h" +#include "libANGLE/Context.h" +#include "libANGLE/Program.h" +#include "libANGLE/Shader.h" +#include "libANGLE/VaryingPacking.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" + +using namespace gl; + +namespace rx +{ + +namespace +{ + +// kShaderStorageDeclarationString must be the same as outputHLSL. +constexpr const char kShaderStorageDeclarationString[] = + "// @@ SHADER STORAGE DECLARATION STRING @@"; + +const char *HLSLComponentTypeString(GLenum componentType) +{ + switch (componentType) + { + case GL_UNSIGNED_INT: + return "uint"; + case GL_INT: + return "int"; + case GL_UNSIGNED_NORMALIZED: + case GL_SIGNED_NORMALIZED: + case GL_FLOAT: + return "float"; + default: + UNREACHABLE(); + return "not-component-type"; + } +} + +void HLSLComponentTypeString(std::ostringstream &ostream, GLenum componentType, int componentCount) +{ + ostream << HLSLComponentTypeString(componentType); + if (componentCount > 1) + { + ostream << componentCount; + } +} + +const char *HLSLMatrixTypeString(GLenum type) +{ + switch (type) + { + case GL_FLOAT_MAT2: + return "float2x2"; + case GL_FLOAT_MAT3: + return "float3x3"; + case GL_FLOAT_MAT4: + return "float4x4"; + case GL_FLOAT_MAT2x3: + return "float2x3"; + case GL_FLOAT_MAT3x2: + return "float3x2"; + case GL_FLOAT_MAT2x4: + return "float2x4"; + case GL_FLOAT_MAT4x2: + return "float4x2"; + case GL_FLOAT_MAT3x4: + return "float3x4"; + case GL_FLOAT_MAT4x3: + return "float4x3"; + default: + UNREACHABLE(); + return "not-matrix-type"; + } +} + +void HLSLTypeString(std::ostringstream &ostream, GLenum type) +{ + if (gl::IsMatrixType(type)) + { + ostream << HLSLMatrixTypeString(type); + return; + } + + HLSLComponentTypeString(ostream, gl::VariableComponentType(type), + gl::VariableComponentCount(type)); +} + +const PixelShaderOutputVariable *FindOutputAtLocation( + const std::vector<PixelShaderOutputVariable> &outputVariables, + unsigned int location, + size_t index = 0) +{ + for (auto &outputVar : outputVariables) + { + if (outputVar.outputLocation == location && outputVar.outputIndex == index) + { + return &outputVar; + } + } + + return nullptr; +} + +void WriteArrayString(std::ostringstream &strstr, unsigned int i) +{ + static_assert(GL_INVALID_INDEX == UINT_MAX, + "GL_INVALID_INDEX must be equal to the max unsigned int."); + if (i == UINT_MAX) + { + return; + } + + strstr << "["; + strstr << i; + strstr << "]"; +} + +bool ReplaceShaderStorageDeclaration(const std::vector<ShaderStorageBlock> &shaderStorageBlocks, + std::string *hlsl, + size_t baseUAVRegister, + gl::ShaderType shaderType) +{ + std::string ssboHeader; + std::ostringstream out(ssboHeader); + for (const ShaderStorageBlock &ssbo : shaderStorageBlocks) + { + size_t uavRegister = baseUAVRegister + ssbo.registerIndex; + std::string name = ssbo.name; + if (ssbo.arraySize > 0) + { + for (unsigned int arrayIndex = 0; arrayIndex < ssbo.arraySize; arrayIndex++) + { + out << "RWByteAddressBuffer " + << "dx_" << name << "_" << arrayIndex << ": register(u" + << uavRegister + arrayIndex << ");\n"; + } + } + else + { + out << "RWByteAddressBuffer " + << "_" << name << ": register(u" << uavRegister << ");\n"; + } + } + if (out.str().empty()) + { + return true; + } + return angle::ReplaceSubstring(hlsl, kShaderStorageDeclarationString, out.str()); +} + +constexpr const char *VERTEX_ATTRIBUTE_STUB_STRING = "@@ VERTEX ATTRIBUTES @@"; +constexpr const char *VERTEX_OUTPUT_STUB_STRING = "@@ VERTEX OUTPUT @@"; +constexpr const char *PIXEL_OUTPUT_STUB_STRING = "@@ PIXEL OUTPUT @@"; +constexpr const char *PIXEL_MAIN_PARAMETERS_STUB_STRING = "@@ PIXEL MAIN PARAMETERS @@"; +constexpr const char *MAIN_PROLOGUE_STUB_STRING = "@@ MAIN PROLOGUE @@"; +} // anonymous namespace + +// BuiltinInfo implementation + +BuiltinInfo::BuiltinInfo() = default; +BuiltinInfo::~BuiltinInfo() = default; + +// DynamicHLSL implementation + +DynamicHLSL::DynamicHLSL(RendererD3D *const renderer) : mRenderer(renderer) {} + +std::string DynamicHLSL::generateVertexShaderForInputLayout( + const std::string &sourceShader, + const InputLayout &inputLayout, + const std::vector<sh::ShaderVariable> &shaderAttributes, + const std::vector<rx::ShaderStorageBlock> &shaderStorageBlocks, + size_t baseUAVRegister) const +{ + std::ostringstream structStream; + std::ostringstream initStream; + + structStream << "struct VS_INPUT\n" + << "{\n"; + + int semanticIndex = 0; + unsigned int inputIndex = 0; + + // If gl_PointSize is used in the shader then pointsprites rendering is expected. + // If the renderer does not support Geometry shaders then Instanced PointSprite emulation + // must be used. + bool usesPointSize = sourceShader.find("GL_USES_POINT_SIZE") != std::string::npos; + bool useInstancedPointSpriteEmulation = + usesPointSize && mRenderer->getFeatures().useInstancedPointSpriteEmulation.enabled; + + // Instanced PointSprite emulation requires additional entries in the + // VS_INPUT structure to support the vertices that make up the quad vertices. + // These values must be in sync with the cooresponding values added during inputlayout creation + // in InputLayoutCache::applyVertexBuffers(). + // + // The additional entries must appear first in the VS_INPUT layout because + // Windows Phone 8 era devices require per vertex data to physically come + // before per instance data in the shader. + if (useInstancedPointSpriteEmulation) + { + structStream << " float3 spriteVertexPos : SPRITEPOSITION0;\n" + << " float2 spriteTexCoord : SPRITETEXCOORD0;\n"; + } + + for (size_t attributeIndex = 0; attributeIndex < shaderAttributes.size(); ++attributeIndex) + { + const sh::ShaderVariable &shaderAttribute = shaderAttributes[attributeIndex]; + if (!shaderAttribute.name.empty()) + { + ASSERT(inputIndex < MAX_VERTEX_ATTRIBS); + angle::FormatID vertexFormatID = + inputIndex < inputLayout.size() ? inputLayout[inputIndex] : angle::FormatID::NONE; + + // HLSL code for input structure + if (IsMatrixType(shaderAttribute.type)) + { + // Matrix types are always transposed + structStream << " " + << HLSLMatrixTypeString(TransposeMatrixType(shaderAttribute.type)); + } + else + { + if (shaderAttribute.name == "gl_InstanceID" || + shaderAttribute.name == "gl_VertexID") + { + // The input types of the instance ID and vertex ID in HLSL (uint) differs from + // the ones in ESSL (int). + structStream << " uint"; + } + else + { + GLenum componentType = mRenderer->getVertexComponentType(vertexFormatID); + + structStream << " "; + HLSLComponentTypeString(structStream, componentType, + VariableComponentCount(shaderAttribute.type)); + } + } + + structStream << " " << DecorateVariable(shaderAttribute.name) << " : "; + + if (shaderAttribute.name == "gl_InstanceID") + { + structStream << "SV_InstanceID"; + } + else if (shaderAttribute.name == "gl_VertexID") + { + structStream << "SV_VertexID"; + } + else + { + structStream << "TEXCOORD" << semanticIndex; + semanticIndex += VariableRegisterCount(shaderAttribute.type); + } + + structStream << ";\n"; + + // HLSL code for initialization + initStream << " " << DecorateVariable(shaderAttribute.name) << " = "; + + // Mismatched vertex attribute to vertex input may result in an undefined + // data reinterpretation (eg for pure integer->float, float->pure integer) + // TODO: issue warning with gl debug info extension, when supported + if (IsMatrixType(shaderAttribute.type) || + (mRenderer->getVertexConversionType(vertexFormatID) & VERTEX_CONVERT_GPU) != 0) + { + GenerateAttributeConversionHLSL(vertexFormatID, shaderAttribute, initStream); + } + else + { + initStream << "input." << DecorateVariable(shaderAttribute.name); + } + + if (shaderAttribute.name == "gl_VertexID") + { + // dx_VertexID contains the firstVertex offset + initStream << " + dx_VertexID"; + } + + initStream << ";\n"; + + inputIndex += VariableRowCount(TransposeMatrixType(shaderAttribute.type)); + } + } + + structStream << "};\n" + "\n" + "void initAttributes(VS_INPUT input)\n" + "{\n" + << initStream.str() << "}\n"; + + std::string vertexHLSL(sourceShader); + + bool success = + angle::ReplaceSubstring(&vertexHLSL, VERTEX_ATTRIBUTE_STUB_STRING, structStream.str()); + ASSERT(success); + + success = ReplaceShaderStorageDeclaration(shaderStorageBlocks, &vertexHLSL, baseUAVRegister, + gl::ShaderType::Vertex); + ASSERT(success); + + return vertexHLSL; +} + +std::string DynamicHLSL::generatePixelShaderForOutputSignature( + const std::string &sourceShader, + const std::vector<PixelShaderOutputVariable> &outputVariables, + bool usesFragDepth, + const std::vector<GLenum> &outputLayout, + const std::vector<ShaderStorageBlock> &shaderStorageBlocks, + size_t baseUAVRegister) const +{ + const int shaderModel = mRenderer->getMajorShaderModel(); + std::string targetSemantic = (shaderModel >= 4) ? "SV_TARGET" : "COLOR"; + std::string depthSemantic = (shaderModel >= 4) ? "SV_Depth" : "DEPTH"; + + std::ostringstream declarationStream; + std::ostringstream copyStream; + + declarationStream << "struct PS_OUTPUT\n" + "{\n"; + + size_t numOutputs = outputLayout.size(); + + // Workaround for HLSL 3.x: We can't do a depth/stencil only render, the runtime will complain. + if (numOutputs == 0 && (shaderModel == 3 || !mRenderer->getShaderModelSuffix().empty())) + { + numOutputs = 1u; + } + const PixelShaderOutputVariable defaultOutput(GL_FLOAT_VEC4, "unused", "float4(0, 0, 0, 1)", 0, + 0); + size_t outputIndex = 0; + + for (size_t layoutIndex = 0; layoutIndex < numOutputs; ++layoutIndex) + { + GLenum binding = outputLayout.empty() ? GL_COLOR_ATTACHMENT0 : outputLayout[layoutIndex]; + + if (binding != GL_NONE) + { + unsigned int location = (binding - GL_COLOR_ATTACHMENT0); + outputIndex = + layoutIndex > 0 && binding == outputLayout[layoutIndex - 1] ? outputIndex + 1 : 0; + + const PixelShaderOutputVariable *outputVariable = + outputLayout.empty() ? &defaultOutput + : FindOutputAtLocation(outputVariables, location, outputIndex); + + // OpenGL ES 3.0 spec $4.2.1 + // If [...] not all user-defined output variables are written, the values of fragment + // colors corresponding to unwritten variables are similarly undefined. + if (outputVariable) + { + declarationStream << " "; + HLSLTypeString(declarationStream, outputVariable->type); + declarationStream << " " << outputVariable->name << " : " << targetSemantic + << static_cast<int>(layoutIndex) << ";\n"; + + copyStream << " output." << outputVariable->name << " = " + << outputVariable->source << ";\n"; + } + } + } + + if (usesFragDepth) + { + declarationStream << " float gl_Depth : " << depthSemantic << ";\n"; + copyStream << " output.gl_Depth = gl_Depth; \n"; + } + + declarationStream << "};\n" + "\n" + "PS_OUTPUT generateOutput()\n" + "{\n" + " PS_OUTPUT output;\n" + << copyStream.str() + << " return output;\n" + "}\n"; + + std::string pixelHLSL(sourceShader); + + bool success = + angle::ReplaceSubstring(&pixelHLSL, PIXEL_OUTPUT_STUB_STRING, declarationStream.str()); + ASSERT(success); + + success = ReplaceShaderStorageDeclaration(shaderStorageBlocks, &pixelHLSL, baseUAVRegister, + gl::ShaderType::Fragment); + ASSERT(success); + + return pixelHLSL; +} + +std::string DynamicHLSL::generateShaderForImage2DBindSignature( + ProgramD3D &programD3D, + const gl::ProgramState &programData, + gl::ShaderType shaderType, + const std::string &shaderHLSL, + std::vector<sh::ShaderVariable> &image2DUniforms, + const gl::ImageUnitTextureTypeMap &image2DBindLayout, + unsigned int baseUAVRegister) const +{ + if (image2DUniforms.empty()) + { + return shaderHLSL; + } + + return GenerateShaderForImage2DBindSignature(programD3D, programData, shaderType, shaderHLSL, + image2DUniforms, image2DBindLayout, + baseUAVRegister); +} + +void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking, + const BuiltinInfo &builtins, + bool programUsesPointSize, + std::ostringstream &hlslStream) const +{ + ASSERT(builtins.dxPosition.enabled); + hlslStream << "{\n" + << " float4 dx_Position : " << builtins.dxPosition.str() << ";\n"; + + if (builtins.glPosition.enabled) + { + hlslStream << " float4 gl_Position : " << builtins.glPosition.str() << ";\n"; + } + + if (builtins.glFragCoord.enabled) + { + hlslStream << " float4 gl_FragCoord : " << builtins.glFragCoord.str() << ";\n"; + } + + if (builtins.glPointCoord.enabled) + { + hlslStream << " float2 gl_PointCoord : " << builtins.glPointCoord.str() << ";\n"; + } + + if (builtins.glPointSize.enabled) + { + hlslStream << " float gl_PointSize : " << builtins.glPointSize.str() << ";\n"; + } + + if (builtins.glViewIDOVR.enabled) + { + hlslStream << " nointerpolation uint gl_ViewID_OVR : " << builtins.glViewIDOVR.str() + << ";\n"; + } + + std::string varyingSemantic = + GetVaryingSemantic(mRenderer->getMajorShaderModel(), programUsesPointSize); + + const auto ®isterInfos = varyingPacking.getRegisterList(); + for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex) + { + const PackedVaryingRegister ®isterInfo = registerInfos[registerIndex]; + const auto &varying = registerInfo.packedVarying->varying(); + ASSERT(!varying.isStruct()); + + // TODO: Add checks to ensure D3D interpolation modifiers don't result in too many + // registers being used. + // For example, if there are N registers, and we have N vec3 varyings and 1 float + // varying, then D3D will pack them into N registers. + // If the float varying has the 'nointerpolation' modifier on it then we would need + // N + 1 registers, and D3D compilation will fail. + + switch (registerInfo.packedVarying->interpolation) + { + case sh::INTERPOLATION_SMOOTH: + hlslStream << " "; + break; + case sh::INTERPOLATION_FLAT: + hlslStream << " nointerpolation "; + break; + case sh::INTERPOLATION_CENTROID: + hlslStream << " centroid "; + break; + case sh::INTERPOLATION_SAMPLE: + hlslStream << " sample "; + break; + default: + UNREACHABLE(); + } + + GLenum transposedType = gl::TransposeMatrixType(varying.type); + GLenum componentType = gl::VariableComponentType(transposedType); + int columnCount = gl::VariableColumnCount(transposedType); + HLSLComponentTypeString(hlslStream, componentType, columnCount); + hlslStream << " v" << registerIndex << " : " << varyingSemantic << registerIndex << ";\n"; + } + + // Note that the following outputs need to be declared after the others. They are not included + // in pixel shader inputs even when they are in vertex/geometry shader outputs, and the pixel + // shader input struct must be a prefix of the vertex/geometry shader output struct. + + if (builtins.glViewportIndex.enabled) + { + hlslStream << " nointerpolation uint gl_ViewportIndex : " + << builtins.glViewportIndex.str() << ";\n"; + } + + if (builtins.glLayer.enabled) + { + hlslStream << " nointerpolation uint gl_Layer : " << builtins.glLayer.str() << ";\n"; + } + + hlslStream << "};\n"; +} + +void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context, + const gl::Caps &caps, + const gl::ProgramState &programData, + const ProgramD3DMetadata &programMetadata, + const VaryingPacking &varyingPacking, + const BuiltinVaryingsD3D &builtinsD3D, + gl::ShaderMap<std::string> *shaderHLSL) const +{ + ASSERT(shaderHLSL); + ASSERT((*shaderHLSL)[gl::ShaderType::Vertex].empty() && + (*shaderHLSL)[gl::ShaderType::Fragment].empty()); + + gl::Shader *vertexShaderGL = programData.getAttachedShader(ShaderType::Vertex); + gl::Shader *fragmentShaderGL = programData.getAttachedShader(ShaderType::Fragment); + const int shaderModel = mRenderer->getMajorShaderModel(); + + const ShaderD3D *fragmentShader = nullptr; + if (fragmentShaderGL) + { + fragmentShader = GetImplAs<ShaderD3D>(fragmentShaderGL); + } + + // usesViewScale() isn't supported in the D3D9 renderer + ASSERT(shaderModel >= 4 || !programMetadata.usesViewScale()); + + bool useInstancedPointSpriteEmulation = + programMetadata.usesPointSize() && + mRenderer->getFeatures().useInstancedPointSpriteEmulation.enabled; + + // Validation done in the compiler + ASSERT(!fragmentShader || !fragmentShader->usesFragColor() || !fragmentShader->usesFragData()); + + std::ostringstream vertexStream; + vertexStream << "struct VS_OUTPUT\n"; + const auto &vertexBuiltins = builtinsD3D[gl::ShaderType::Vertex]; + generateVaryingLinkHLSL(varyingPacking, vertexBuiltins, builtinsD3D.usesPointSize(), + vertexStream); + + // Instanced PointSprite emulation requires additional entries originally generated in the + // GeometryShader HLSL. These include pointsize clamp values. + if (useInstancedPointSpriteEmulation) + { + vertexStream << "static float minPointSize = " << static_cast<int>(caps.minAliasedPointSize) + << ".0f;\n" + << "static float maxPointSize = " << static_cast<int>(caps.maxAliasedPointSize) + << ".0f;\n"; + } + + std::ostringstream vertexGenerateOutput; + vertexGenerateOutput << "VS_OUTPUT generateOutput(VS_INPUT input)\n" + << "{\n" + << " VS_OUTPUT output;\n"; + + if (vertexBuiltins.glPosition.enabled) + { + vertexGenerateOutput << " output.gl_Position = gl_Position;\n"; + } + + if (vertexBuiltins.glViewIDOVR.enabled) + { + vertexGenerateOutput << " output.gl_ViewID_OVR = ViewID_OVR;\n"; + } + if (programMetadata.hasANGLEMultiviewEnabled() && programMetadata.canSelectViewInVertexShader()) + { + ASSERT(vertexBuiltins.glViewportIndex.enabled && vertexBuiltins.glLayer.enabled); + vertexGenerateOutput << " if (multiviewSelectViewportIndex)\n" + << " {\n" + << " output.gl_ViewportIndex = ViewID_OVR;\n" + << " } else {\n" + << " output.gl_ViewportIndex = 0;\n" + << " output.gl_Layer = ViewID_OVR;\n" + << " }\n"; + } + + // On D3D9 or D3D11 Feature Level 9, we need to emulate large viewports using dx_ViewAdjust. + if (shaderModel >= 4 && mRenderer->getShaderModelSuffix() == "") + { + vertexGenerateOutput << " output.dx_Position.x = gl_Position.x;\n"; + + if (programMetadata.usesViewScale()) + { + // This code assumes that dx_ViewScale.y = -1.0f when rendering to texture, and +1.0f + // when rendering to the default framebuffer. No other values are valid. + vertexGenerateOutput << " output.dx_Position.y = dx_ViewScale.y * gl_Position.y;\n"; + } + else + { + vertexGenerateOutput + << " output.dx_Position.y = clipControlOrigin * gl_Position.y;\n"; + } + + vertexGenerateOutput + << " if (clipControlZeroToOne)\n" + << " {\n" + << " output.dx_Position.z = gl_Position.z;\n" + << " } else {\n" + << " output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n" + << " }\n"; + + vertexGenerateOutput << " output.dx_Position.w = gl_Position.w;\n"; + } + else + { + vertexGenerateOutput << " output.dx_Position.x = gl_Position.x * dx_ViewAdjust.z + " + "dx_ViewAdjust.x * gl_Position.w;\n"; + + // If usesViewScale() is true and we're using the D3D11 renderer via Feature Level 9_*, + // then we need to multiply the gl_Position.y by the viewScale. + // usesViewScale() isn't supported when using the D3D9 renderer. + if (programMetadata.usesViewScale() && + (shaderModel >= 4 && mRenderer->getShaderModelSuffix() != "")) + { + vertexGenerateOutput << " output.dx_Position.y = dx_ViewScale.y * (gl_Position.y * " + "dx_ViewAdjust.w + dx_ViewAdjust.y * gl_Position.w);\n"; + } + else + { + vertexGenerateOutput << " output.dx_Position.y = clipControlOrigin * (gl_Position.y " + "* dx_ViewAdjust.w + " + "dx_ViewAdjust.y * gl_Position.w);\n"; + } + + vertexGenerateOutput + << " if (clipControlZeroToOne)\n" + << " {\n" + << " output.dx_Position.z = gl_Position.z;\n" + << " } else {\n" + << " output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n" + << " }\n"; + + vertexGenerateOutput << " output.dx_Position.w = gl_Position.w;\n"; + } + + // We don't need to output gl_PointSize if we use are emulating point sprites via instancing. + if (vertexBuiltins.glPointSize.enabled) + { + vertexGenerateOutput << " output.gl_PointSize = gl_PointSize;\n"; + } + + if (vertexBuiltins.glFragCoord.enabled) + { + vertexGenerateOutput << " output.gl_FragCoord = gl_Position;\n"; + } + + const auto ®isterInfos = varyingPacking.getRegisterList(); + for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex) + { + const PackedVaryingRegister ®isterInfo = registerInfos[registerIndex]; + const auto &packedVarying = *registerInfo.packedVarying; + const auto &varying = *packedVarying.frontVarying.varying; + ASSERT(!varying.isStruct()); + + vertexGenerateOutput << " output.v" << registerIndex << " = "; + + if (packedVarying.isStructField()) + { + vertexGenerateOutput << DecorateVariable(packedVarying.frontVarying.parentStructName) + << "."; + } + + vertexGenerateOutput << DecorateVariable(varying.name); + + if (varying.isArray()) + { + WriteArrayString(vertexGenerateOutput, registerInfo.varyingArrayIndex); + } + + if (VariableRowCount(varying.type) > 1) + { + WriteArrayString(vertexGenerateOutput, registerInfo.varyingRowIndex); + } + + vertexGenerateOutput << ";\n"; + } + + // Instanced PointSprite emulation requires additional entries to calculate + // the final output vertex positions of the quad that represents each sprite. + if (useInstancedPointSpriteEmulation) + { + vertexGenerateOutput + << "\n" + << " gl_PointSize = clamp(gl_PointSize, minPointSize, maxPointSize);\n"; + + vertexGenerateOutput + << " output.dx_Position.x += (input.spriteVertexPos.x * gl_PointSize / " + "(dx_ViewCoords.x*2)) * output.dx_Position.w;"; + + if (programMetadata.usesViewScale()) + { + // Multiply by ViewScale to invert the rendering when appropriate + vertexGenerateOutput + << " output.dx_Position.y += (-dx_ViewScale.y * " + "input.spriteVertexPos.y * gl_PointSize / (dx_ViewCoords.y*2)) * " + "output.dx_Position.w;"; + } + else + { + vertexGenerateOutput + << " output.dx_Position.y += (input.spriteVertexPos.y * gl_PointSize / " + "(dx_ViewCoords.y*2)) * output.dx_Position.w;"; + } + + vertexGenerateOutput + << " output.dx_Position.z += input.spriteVertexPos.z * output.dx_Position.w;\n"; + + if (programMetadata.usesPointCoord()) + { + vertexGenerateOutput << "\n" + << " output.gl_PointCoord = input.spriteTexCoord;\n"; + } + } + + // Renderers that enable instanced pointsprite emulation require the vertex shader output member + // gl_PointCoord to be set to a default value if used without gl_PointSize. 0.5,0.5 is the same + // default value used in the generated pixel shader. + if (programMetadata.usesInsertedPointCoordValue()) + { + ASSERT(!useInstancedPointSpriteEmulation); + vertexGenerateOutput << "\n" + << " output.gl_PointCoord = float2(0.5, 0.5);\n"; + } + + vertexGenerateOutput << "\n" + << " return output;\n" + << "}"; + + if (vertexShaderGL) + { + std::string vertexSource = vertexShaderGL->getTranslatedSource(context); + angle::ReplaceSubstring(&vertexSource, std::string(MAIN_PROLOGUE_STUB_STRING), + " initAttributes(input);\n"); + angle::ReplaceSubstring(&vertexSource, std::string(VERTEX_OUTPUT_STUB_STRING), + vertexGenerateOutput.str()); + vertexStream << vertexSource; + } + + const auto &pixelBuiltins = builtinsD3D[gl::ShaderType::Fragment]; + + std::ostringstream pixelStream; + pixelStream << "struct PS_INPUT\n"; + generateVaryingLinkHLSL(varyingPacking, pixelBuiltins, builtinsD3D.usesPointSize(), + pixelStream); + pixelStream << "\n"; + + std::ostringstream pixelPrologue; + if (fragmentShader && fragmentShader->usesViewID()) + { + ASSERT(pixelBuiltins.glViewIDOVR.enabled); + pixelPrologue << " ViewID_OVR = input.gl_ViewID_OVR;\n"; + } + + if (pixelBuiltins.glFragCoord.enabled) + { + pixelPrologue << " float rhw = 1.0 / input.gl_FragCoord.w;\n"; + + // Certain Shader Models (4_0+ and 3_0) allow reading from dx_Position in the pixel shader. + // Other Shader Models (4_0_level_9_3 and 2_x) don't support this, so we emulate it using + // dx_ViewCoords. + // DComp usually gives us an offset at (0, 0), but this is not always the case. It is + // valid for DComp to give us an offset into the texture atlas. In that scenario, we + // need to offset gl_FragCoord using dx_FragCoordOffset to point to the correct location + // of the pixel. + if (shaderModel >= 4 && mRenderer->getShaderModelSuffix() == "") + { + pixelPrologue << " gl_FragCoord.x = input.dx_Position.x - dx_FragCoordOffset.x;\n" + << " gl_FragCoord.y = input.dx_Position.y - dx_FragCoordOffset.y;\n"; + } + else if (shaderModel == 3) + { + pixelPrologue + << " gl_FragCoord.x = input.dx_Position.x + 0.5 - dx_FragCoordOffset.x;\n" + << " gl_FragCoord.y = input.dx_Position.y + 0.5 - dx_FragCoordOffset.y;\n"; + } + else + { + // dx_ViewCoords contains the viewport width/2, height/2, center.x and center.y. See + // Renderer::setViewport() + pixelPrologue + << " gl_FragCoord.x = (input.gl_FragCoord.x * rhw) * dx_ViewCoords.x + " + "dx_ViewCoords.z - dx_FragCoordOffset.x;\n" + << " gl_FragCoord.y = (input.gl_FragCoord.y * rhw) * dx_ViewCoords.y + " + "dx_ViewCoords.w - dx_FragCoordOffset.y;\n"; + } + + if (programMetadata.usesViewScale()) + { + // For Feature Level 9_3 and below, we need to correct gl_FragCoord.y to account + // for dx_ViewScale. On Feature Level 10_0+, gl_FragCoord.y is calculated above using + // dx_ViewCoords and is always correct irrespective of dx_ViewScale's value. + // NOTE: usesViewScale() can only be true on D3D11 (i.e. Shader Model 4.0+). + if (shaderModel >= 4 && mRenderer->getShaderModelSuffix() == "") + { + // Some assumptions: + // - dx_ViewScale.y = -1.0f when rendering to texture + // - dx_ViewScale.y = +1.0f when rendering to the default framebuffer + // - gl_FragCoord.y has been set correctly above. + // + // When rendering to the backbuffer, the code inverts gl_FragCoord's y coordinate. + // This involves subtracting the y coordinate from the height of the area being + // rendered to. + // + // First we calculate the height of the area being rendered to: + // render_area_height = (2.0f / (1.0f - input.gl_FragCoord.y * rhw)) * + // gl_FragCoord.y + // + // Note that when we're rendering to default FB, we want our output to be + // equivalent to: + // "gl_FragCoord.y = render_area_height - gl_FragCoord.y" + // + // When we're rendering to a texture, we want our output to be equivalent to: + // "gl_FragCoord.y = gl_FragCoord.y;" + // + // If we set scale_factor = ((1.0f + dx_ViewScale.y) / 2.0f), then notice that + // - When rendering to default FB: scale_factor = 1.0f + // - When rendering to texture: scale_factor = 0.0f + // + // Therefore, we can get our desired output by setting: + // "gl_FragCoord.y = scale_factor * render_area_height - dx_ViewScale.y * + // gl_FragCoord.y" + // + // Simplifying, this becomes: + pixelPrologue + << " gl_FragCoord.y = (1.0f + dx_ViewScale.y) * gl_FragCoord.y /" + "(1.0f - input.gl_FragCoord.y * rhw) - dx_ViewScale.y * gl_FragCoord.y;\n"; + } + } + + pixelPrologue << " gl_FragCoord.z = (input.gl_FragCoord.z * rhw) * dx_DepthFront.x + " + "dx_DepthFront.y;\n" + << " gl_FragCoord.w = rhw;\n"; + } + + if (pixelBuiltins.glPointCoord.enabled && shaderModel >= 3) + { + pixelPrologue << " gl_PointCoord.x = input.gl_PointCoord.x;\n" + << " gl_PointCoord.y = 1.0 - input.gl_PointCoord.y;\n"; + } + + if (fragmentShader && fragmentShader->usesFrontFacing()) + { + if (shaderModel <= 3) + { + pixelPrologue << " gl_FrontFacing = (vFace * dx_DepthFront.z >= 0.0);\n"; + } + else + { + pixelPrologue << " gl_FrontFacing = isFrontFace;\n"; + } + } + + for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex) + { + const PackedVaryingRegister ®isterInfo = registerInfos[registerIndex]; + const auto &packedVarying = *registerInfo.packedVarying; + + // Don't reference VS-only transform feedback varyings in the PS. + if (packedVarying.vertexOnly()) + { + continue; + } + + const auto &varying = *packedVarying.backVarying.varying; + ASSERT(!varying.isBuiltIn() && !varying.isStruct()); + + // Note that we're relying on that the active flag is set according to usage in the fragment + // shader. + if (!varying.active) + { + continue; + } + + pixelPrologue << " "; + + if (packedVarying.isStructField()) + { + pixelPrologue << DecorateVariable(packedVarying.backVarying.parentStructName) << "."; + } + + pixelPrologue << DecorateVariable(varying.name); + + if (varying.isArray()) + { + WriteArrayString(pixelPrologue, registerInfo.varyingArrayIndex); + } + + GLenum transposedType = TransposeMatrixType(varying.type); + if (VariableRowCount(transposedType) > 1) + { + WriteArrayString(pixelPrologue, registerInfo.varyingRowIndex); + } + + pixelPrologue << " = input.v" << registerIndex; + + switch (VariableColumnCount(transposedType)) + { + case 1: + pixelPrologue << ".x"; + break; + case 2: + pixelPrologue << ".xy"; + break; + case 3: + pixelPrologue << ".xyz"; + break; + case 4: + break; + default: + UNREACHABLE(); + } + pixelPrologue << ";\n"; + } + + if (fragmentShaderGL) + { + std::string pixelSource = fragmentShaderGL->getTranslatedSource(context); + + if (fragmentShader->usesFrontFacing()) + { + if (shaderModel >= 4) + { + angle::ReplaceSubstring(&pixelSource, + std::string(PIXEL_MAIN_PARAMETERS_STUB_STRING), + "PS_INPUT input, bool isFrontFace : SV_IsFrontFace"); + } + else + { + angle::ReplaceSubstring(&pixelSource, + std::string(PIXEL_MAIN_PARAMETERS_STUB_STRING), + "PS_INPUT input, float vFace : VFACE"); + } + } + else + { + angle::ReplaceSubstring(&pixelSource, std::string(PIXEL_MAIN_PARAMETERS_STUB_STRING), + "PS_INPUT input"); + } + + angle::ReplaceSubstring(&pixelSource, std::string(MAIN_PROLOGUE_STUB_STRING), + pixelPrologue.str()); + pixelStream << pixelSource; + } + + (*shaderHLSL)[gl::ShaderType::Vertex] = vertexStream.str(); + (*shaderHLSL)[gl::ShaderType::Fragment] = pixelStream.str(); +} + +std::string DynamicHLSL::generateGeometryShaderPreamble(const VaryingPacking &varyingPacking, + const BuiltinVaryingsD3D &builtinsD3D, + const bool hasANGLEMultiviewEnabled, + const bool selectViewInVS) const +{ + ASSERT(mRenderer->getMajorShaderModel() >= 4); + + std::ostringstream preambleStream; + + const auto &vertexBuiltins = builtinsD3D[gl::ShaderType::Vertex]; + + preambleStream << "struct GS_INPUT\n"; + generateVaryingLinkHLSL(varyingPacking, vertexBuiltins, builtinsD3D.usesPointSize(), + preambleStream); + preambleStream << "\n" + << "struct GS_OUTPUT\n"; + generateVaryingLinkHLSL(varyingPacking, builtinsD3D[gl::ShaderType::Geometry], + builtinsD3D.usesPointSize(), preambleStream); + preambleStream + << "\n" + << "void copyVertex(inout GS_OUTPUT output, GS_INPUT input, GS_INPUT flatinput)\n" + << "{\n" + << " output.gl_Position = input.gl_Position;\n"; + + if (vertexBuiltins.glPointSize.enabled) + { + preambleStream << " output.gl_PointSize = input.gl_PointSize;\n"; + } + + if (hasANGLEMultiviewEnabled) + { + preambleStream << " output.gl_ViewID_OVR = input.gl_ViewID_OVR;\n"; + if (selectViewInVS) + { + ASSERT(builtinsD3D[gl::ShaderType::Geometry].glViewportIndex.enabled && + builtinsD3D[gl::ShaderType::Geometry].glLayer.enabled); + + // If the view is already selected in the VS, then we just pass the gl_ViewportIndex and + // gl_Layer to the output. + preambleStream << " output.gl_ViewportIndex = input.gl_ViewportIndex;\n" + << " output.gl_Layer = input.gl_Layer;\n"; + } + } + + const auto ®isterInfos = varyingPacking.getRegisterList(); + for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex) + { + const PackedVaryingRegister &varyingRegister = registerInfos[registerIndex]; + preambleStream << " output.v" << registerIndex << " = "; + if (varyingRegister.packedVarying->interpolation == sh::INTERPOLATION_FLAT) + { + preambleStream << "flat"; + } + preambleStream << "input.v" << registerIndex << "; \n"; + } + + if (vertexBuiltins.glFragCoord.enabled) + { + preambleStream << " output.gl_FragCoord = input.gl_FragCoord;\n"; + } + + // Only write the dx_Position if we aren't using point sprites + preambleStream << "#ifndef ANGLE_POINT_SPRITE_SHADER\n" + << " output.dx_Position = input.dx_Position;\n" + << "#endif // ANGLE_POINT_SPRITE_SHADER\n" + << "}\n"; + + if (hasANGLEMultiviewEnabled && !selectViewInVS) + { + ASSERT(builtinsD3D[gl::ShaderType::Geometry].glViewportIndex.enabled && + builtinsD3D[gl::ShaderType::Geometry].glLayer.enabled); + + // According to the HLSL reference, using SV_RenderTargetArrayIndex is only valid if the + // render target is an array resource. Because of this we do not write to gl_Layer if we are + // taking the side-by-side code path. We still select the viewport index in the layered code + // path as that is always valid. See: + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb509647(v=vs.85).aspx + preambleStream << "\n" + << "void selectView(inout GS_OUTPUT output, GS_INPUT input)\n" + << "{\n" + << " if (multiviewSelectViewportIndex)\n" + << " {\n" + << " output.gl_ViewportIndex = input.gl_ViewID_OVR;\n" + << " } else {\n" + << " output.gl_ViewportIndex = 0;\n" + << " output.gl_Layer = input.gl_ViewID_OVR;\n" + << " }\n" + << "}\n"; + } + + return preambleStream.str(); +} + +std::string DynamicHLSL::generateGeometryShaderHLSL(const gl::Caps &caps, + gl::PrimitiveMode primitiveType, + const gl::ProgramState &programData, + const bool useViewScale, + const bool hasANGLEMultiviewEnabled, + const bool selectViewInVS, + const bool pointSpriteEmulation, + const std::string &preambleString) const +{ + ASSERT(mRenderer->getMajorShaderModel() >= 4); + + std::stringstream shaderStream; + + const bool pointSprites = (primitiveType == gl::PrimitiveMode::Points) && pointSpriteEmulation; + const bool usesPointCoord = preambleString.find("gl_PointCoord") != std::string::npos; + + const char *inputPT = nullptr; + const char *outputPT = nullptr; + int inputSize = 0; + int maxVertexOutput = 0; + + switch (primitiveType) + { + case gl::PrimitiveMode::Points: + inputPT = "point"; + inputSize = 1; + + if (pointSprites) + { + outputPT = "Triangle"; + maxVertexOutput = 4; + } + else + { + outputPT = "Point"; + maxVertexOutput = 1; + } + + break; + + case gl::PrimitiveMode::Lines: + case gl::PrimitiveMode::LineStrip: + case gl::PrimitiveMode::LineLoop: + inputPT = "line"; + outputPT = "Line"; + inputSize = 2; + maxVertexOutput = 2; + break; + + case gl::PrimitiveMode::Triangles: + case gl::PrimitiveMode::TriangleStrip: + case gl::PrimitiveMode::TriangleFan: + inputPT = "triangle"; + outputPT = "Triangle"; + inputSize = 3; + maxVertexOutput = 3; + break; + + default: + UNREACHABLE(); + break; + } + + if (pointSprites || hasANGLEMultiviewEnabled) + { + shaderStream << "cbuffer DriverConstants : register(b0)\n" + "{\n"; + + if (pointSprites) + { + shaderStream << " float4 dx_ViewCoords : packoffset(c1);\n"; + if (useViewScale) + { + shaderStream << " float2 dx_ViewScale : packoffset(c3.z);\n"; + } + } + + if (hasANGLEMultiviewEnabled) + { + // We have to add a value which we can use to keep track of which multi-view code path + // is to be selected in the GS. + shaderStream << " float multiviewSelectViewportIndex : packoffset(c4.x);\n"; + } + + shaderStream << "};\n\n"; + } + + if (pointSprites) + { + shaderStream << "#define ANGLE_POINT_SPRITE_SHADER\n" + "\n" + "static float2 pointSpriteCorners[] = \n" + "{\n" + " float2( 0.5f, -0.5f),\n" + " float2( 0.5f, 0.5f),\n" + " float2(-0.5f, -0.5f),\n" + " float2(-0.5f, 0.5f)\n" + "};\n" + "\n" + "static float2 pointSpriteTexcoords[] = \n" + "{\n" + " float2(1.0f, 1.0f),\n" + " float2(1.0f, 0.0f),\n" + " float2(0.0f, 1.0f),\n" + " float2(0.0f, 0.0f)\n" + "};\n" + "\n" + "static float minPointSize = " + << static_cast<int>(caps.minAliasedPointSize) + << ".0f;\n" + "static float maxPointSize = " + << static_cast<int>(caps.maxAliasedPointSize) << ".0f;\n" + << "\n"; + } + + shaderStream << preambleString << "\n" + << "[maxvertexcount(" << maxVertexOutput << ")]\n" + << "void main(" << inputPT << " GS_INPUT input[" << inputSize << "], "; + + if (primitiveType == gl::PrimitiveMode::TriangleStrip) + { + shaderStream << "uint primitiveID : SV_PrimitiveID, "; + } + + shaderStream << " inout " << outputPT << "Stream<GS_OUTPUT> outStream)\n" + << "{\n" + << " GS_OUTPUT output = (GS_OUTPUT)0;\n"; + + if (primitiveType == gl::PrimitiveMode::TriangleStrip) + { + shaderStream << " uint lastVertexIndex = (primitiveID % 2 == 0 ? 2 : 1);\n"; + } + else + { + shaderStream << " uint lastVertexIndex = " << (inputSize - 1) << ";\n"; + } + + for (int vertexIndex = 0; vertexIndex < inputSize; ++vertexIndex) + { + shaderStream << " copyVertex(output, input[" << vertexIndex + << "], input[lastVertexIndex]);\n"; + if (hasANGLEMultiviewEnabled && !selectViewInVS) + { + shaderStream << " selectView(output, input[" << vertexIndex << "]);\n"; + } + if (!pointSprites) + { + ASSERT(inputSize == maxVertexOutput); + shaderStream << " outStream.Append(output);\n"; + } + } + + if (pointSprites) + { + shaderStream << "\n" + " float4 dx_Position = input[0].dx_Position;\n" + " float gl_PointSize = clamp(input[0].gl_PointSize, minPointSize, " + "maxPointSize);\n" + " float2 viewportScale = float2(1.0f / dx_ViewCoords.x, 1.0f / " + "dx_ViewCoords.y) * dx_Position.w;\n"; + + for (int corner = 0; corner < 4; corner++) + { + if (useViewScale) + { + shaderStream << " \n" + " output.dx_Position = dx_Position + float4(1.0f, " + "-dx_ViewScale.y, 1.0f, 1.0f)" + " * float4(pointSpriteCorners[" + << corner << "] * viewportScale * gl_PointSize, 0.0f, 0.0f);\n"; + } + else + { + shaderStream << "\n" + " output.dx_Position = dx_Position + float4(pointSpriteCorners[" + << corner << "] * viewportScale * gl_PointSize, 0.0f, 0.0f);\n"; + } + + if (usesPointCoord) + { + shaderStream << " output.gl_PointCoord = pointSpriteTexcoords[" << corner + << "];\n"; + } + + shaderStream << " outStream.Append(output);\n"; + } + } + + shaderStream << " \n" + " outStream.RestartStrip();\n" + "}\n"; + + return shaderStream.str(); +} + +// static +void DynamicHLSL::GenerateAttributeConversionHLSL(angle::FormatID vertexFormatID, + const sh::ShaderVariable &shaderAttrib, + std::ostringstream &outStream) +{ + // Matrix + if (IsMatrixType(shaderAttrib.type)) + { + outStream << "transpose(input." << DecorateVariable(shaderAttrib.name) << ")"; + return; + } + + GLenum shaderComponentType = VariableComponentType(shaderAttrib.type); + int shaderComponentCount = VariableComponentCount(shaderAttrib.type); + const gl::VertexFormat &vertexFormat = gl::GetVertexFormatFromID(vertexFormatID); + + // Perform integer to float conversion (if necessary) + if (shaderComponentType == GL_FLOAT && vertexFormat.type != GL_FLOAT) + { + // TODO: normalization for 32-bit integer formats + ASSERT(!vertexFormat.normalized && !vertexFormat.pureInteger); + outStream << "float" << shaderComponentCount << "(input." + << DecorateVariable(shaderAttrib.name) << ")"; + return; + } + + // No conversion necessary + outStream << "input." << DecorateVariable(shaderAttrib.name); +} + +void DynamicHLSL::getPixelShaderOutputKey(const gl::State &data, + const gl::ProgramState &programData, + const ProgramD3DMetadata &metadata, + std::vector<PixelShaderOutputVariable> *outPixelShaderKey) +{ + // Two cases when writing to gl_FragColor and using ESSL 1.0: + // - with a 3.0 context, the output color is copied to channel 0 + // - with a 2.0 context, the output color is broadcast to all channels + bool broadcast = metadata.usesBroadcast(data); + const unsigned int numRenderTargets = + (broadcast || metadata.usesMultipleFragmentOuts() + ? static_cast<unsigned int>(data.getCaps().maxDrawBuffers) + : 1); + + if (!metadata.usesCustomOutVars()) + { + for (unsigned int renderTargetIndex = 0; renderTargetIndex < numRenderTargets; + renderTargetIndex++) + { + PixelShaderOutputVariable outputKeyVariable; + outputKeyVariable.type = GL_FLOAT_VEC4; + outputKeyVariable.name = "gl_Color" + Str(renderTargetIndex); + outputKeyVariable.source = + broadcast ? "gl_Color[0]" : "gl_Color[" + Str(renderTargetIndex) + "]"; + outputKeyVariable.outputLocation = renderTargetIndex; + + outPixelShaderKey->push_back(outputKeyVariable); + } + + if (metadata.usesSecondaryColor()) + { + for (unsigned int secondaryIndex = 0; + secondaryIndex < data.getCaps().maxDualSourceDrawBuffers; secondaryIndex++) + { + PixelShaderOutputVariable outputKeyVariable; + outputKeyVariable.type = GL_FLOAT_VEC4; + outputKeyVariable.name = "gl_SecondaryColor" + Str(secondaryIndex); + outputKeyVariable.source = "gl_SecondaryColor[" + Str(secondaryIndex) + "]"; + outputKeyVariable.outputLocation = secondaryIndex; + outputKeyVariable.outputIndex = 1; + + outPixelShaderKey->push_back(outputKeyVariable); + } + } + } + else + { + const ShaderD3D *fragmentShader = metadata.getFragmentShader(); + + if (!fragmentShader) + { + return; + } + + const auto &shaderOutputVars = fragmentShader->getState().getActiveOutputVariables(); + + for (size_t outputLocationIndex = 0u; + outputLocationIndex < programData.getOutputLocations().size(); ++outputLocationIndex) + { + const VariableLocation &outputLocation = + programData.getOutputLocations().at(outputLocationIndex); + if (!outputLocation.used()) + { + continue; + } + const sh::ShaderVariable &outputVariable = shaderOutputVars[outputLocation.index]; + const std::string &variableName = "out_" + outputVariable.name; + + // Fragment outputs can't be arrays of arrays. ESSL 3.10 section 4.3.6. + const std::string &elementString = + (outputVariable.isArray() ? Str(outputLocation.arrayIndex) : ""); + + ASSERT(outputVariable.active); + + PixelShaderOutputVariable outputKeyVariable; + outputKeyVariable.type = outputVariable.type; + outputKeyVariable.name = variableName + elementString; + outputKeyVariable.source = + variableName + + (outputVariable.isArray() ? ArrayString(outputLocation.arrayIndex) : ""); + outputKeyVariable.outputLocation = outputLocationIndex; + + outPixelShaderKey->push_back(outputKeyVariable); + } + + // Now generate any secondary outputs... + for (size_t outputLocationIndex = 0u; + outputLocationIndex < programData.getSecondaryOutputLocations().size(); + ++outputLocationIndex) + { + const VariableLocation &outputLocation = + programData.getSecondaryOutputLocations().at(outputLocationIndex); + if (!outputLocation.used()) + { + continue; + } + const sh::ShaderVariable &outputVariable = shaderOutputVars[outputLocation.index]; + const std::string &variableName = "out_" + outputVariable.name; + + // Fragment outputs can't be arrays of arrays. ESSL 3.10 section 4.3.6. + const std::string &elementString = + (outputVariable.isArray() ? Str(outputLocation.arrayIndex) : ""); + + ASSERT(outputVariable.active); + + PixelShaderOutputVariable outputKeyVariable; + outputKeyVariable.type = outputVariable.type; + outputKeyVariable.name = variableName + elementString; + outputKeyVariable.source = + variableName + + (outputVariable.isArray() ? ArrayString(outputLocation.arrayIndex) : ""); + outputKeyVariable.outputLocation = outputLocationIndex; + outputKeyVariable.outputIndex = 1; + + outPixelShaderKey->push_back(outputKeyVariable); + } + } +} + +// BuiltinVarying Implementation. +BuiltinVarying::BuiltinVarying() : enabled(false), index(0), systemValue(false) {} + +std::string BuiltinVarying::str() const +{ + return (systemValue ? semantic : (semantic + Str(index))); +} + +void BuiltinVarying::enableSystem(const std::string &systemValueSemantic) +{ + enabled = true; + semantic = systemValueSemantic; + systemValue = true; +} + +void BuiltinVarying::enable(const std::string &semanticVal, unsigned int indexVal) +{ + enabled = true; + semantic = semanticVal; + index = indexVal; +} + +// BuiltinVaryingsD3D Implementation. +BuiltinVaryingsD3D::BuiltinVaryingsD3D(const ProgramD3DMetadata &metadata, + const VaryingPacking &packing) +{ + updateBuiltins(gl::ShaderType::Vertex, metadata, packing); + updateBuiltins(gl::ShaderType::Fragment, metadata, packing); + int shaderModel = metadata.getRendererMajorShaderModel(); + if (shaderModel >= 4) + { + updateBuiltins(gl::ShaderType::Geometry, metadata, packing); + } + // In shader model >= 4, some builtins need to be the same in vertex and pixel shaders - input + // struct needs to be a prefix of output struct. + ASSERT(shaderModel < 4 || mBuiltinInfo[gl::ShaderType::Vertex].glPosition.enabled == + mBuiltinInfo[gl::ShaderType::Fragment].glPosition.enabled); + ASSERT(shaderModel < 4 || mBuiltinInfo[gl::ShaderType::Vertex].glFragCoord.enabled == + mBuiltinInfo[gl::ShaderType::Fragment].glFragCoord.enabled); + ASSERT(shaderModel < 4 || mBuiltinInfo[gl::ShaderType::Vertex].glPointCoord.enabled == + mBuiltinInfo[gl::ShaderType::Fragment].glPointCoord.enabled); + ASSERT(shaderModel < 4 || mBuiltinInfo[gl::ShaderType::Vertex].glPointSize.enabled == + mBuiltinInfo[gl::ShaderType::Fragment].glPointSize.enabled); + ASSERT(shaderModel < 4 || mBuiltinInfo[gl::ShaderType::Vertex].glViewIDOVR.enabled == + mBuiltinInfo[gl::ShaderType::Fragment].glViewIDOVR.enabled); +} + +BuiltinVaryingsD3D::~BuiltinVaryingsD3D() = default; + +void BuiltinVaryingsD3D::updateBuiltins(gl::ShaderType shaderType, + const ProgramD3DMetadata &metadata, + const VaryingPacking &packing) +{ + const std::string &userSemantic = GetVaryingSemantic(metadata.getRendererMajorShaderModel(), + metadata.usesSystemValuePointSize()); + + // Note that when enabling builtins only for specific shader stages in shader model >= 4, the + // code needs to ensure that the input struct of the shader stage is a prefix of the output + // struct of the previous stage. + + unsigned int reservedSemanticIndex = packing.getMaxSemanticIndex(); + + BuiltinInfo *builtins = &mBuiltinInfo[shaderType]; + + if (metadata.getRendererMajorShaderModel() >= 4) + { + builtins->dxPosition.enableSystem("SV_Position"); + } + else if (shaderType == gl::ShaderType::Fragment) + { + builtins->dxPosition.enableSystem("VPOS"); + } + else + { + builtins->dxPosition.enableSystem("POSITION"); + } + + if (metadata.usesTransformFeedbackGLPosition()) + { + builtins->glPosition.enable(userSemantic, reservedSemanticIndex++); + } + + if (metadata.usesFragCoord()) + { + builtins->glFragCoord.enable(userSemantic, reservedSemanticIndex++); + } + + if (shaderType == gl::ShaderType::Vertex ? metadata.addsPointCoordToVertexShader() + : metadata.usesPointCoord()) + { + // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord) + // In D3D11 we manually compute gl_PointCoord in the GS. + if (metadata.getRendererMajorShaderModel() >= 4) + { + builtins->glPointCoord.enable(userSemantic, reservedSemanticIndex++); + } + else + { + builtins->glPointCoord.enable("TEXCOORD", 0); + } + } + + if (metadata.hasANGLEMultiviewEnabled()) + { + // Although it is possible to compute gl_ViewID_OVR from the value of + // SV_ViewportArrayIndex or SV_RenderTargetArrayIndex and the multi-view state in the + // driver constant buffer, it is easier and cleaner to always pass it as a varying. + builtins->glViewIDOVR.enable(userSemantic, reservedSemanticIndex++); + + if (shaderType == gl::ShaderType::Vertex) + { + if (metadata.canSelectViewInVertexShader()) + { + builtins->glViewportIndex.enableSystem("SV_ViewportArrayIndex"); + builtins->glLayer.enableSystem("SV_RenderTargetArrayIndex"); + } + } + + if (shaderType == gl::ShaderType::Geometry) + { + // gl_Layer and gl_ViewportIndex are necessary so that we can write to either based on + // the multiview state in the driver constant buffer. + builtins->glViewportIndex.enableSystem("SV_ViewportArrayIndex"); + builtins->glLayer.enableSystem("SV_RenderTargetArrayIndex"); + } + } + + // Special case: do not include PSIZE semantic in HLSL 3 pixel shaders + if (metadata.usesSystemValuePointSize() && + (shaderType != gl::ShaderType::Fragment || metadata.getRendererMajorShaderModel() >= 4)) + { + builtins->glPointSize.enableSystem("PSIZE"); + } +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.h new file mode 100644 index 0000000000..3398bae8d7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicHLSL.h @@ -0,0 +1,212 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DynamicHLSL.h: Interface for link and run-time HLSL generation +// + +#ifndef LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_ +#define LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_ + +#include <map> +#include <vector> + +#include "angle_gl.h" +#include "common/angleutils.h" +#include "libANGLE/Constants.h" +#include "libANGLE/Program.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/DynamicImage2DHLSL.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace sh +{ +struct ShaderVariable; +} // namespace sh + +namespace gl +{ +class InfoLog; +struct VariableLocation; +class VaryingPacking; +struct VertexAttribute; +} // namespace gl + +namespace rx +{ +class ProgramD3DMetadata; +class ShaderD3D; +struct ShaderStorageBlock; + +// This class needs to match OutputHLSL::decorate +class DecorateVariable final : angle::NonCopyable +{ + public: + explicit DecorateVariable(const std::string &str) : mName(str) {} + const std::string &getName() const { return mName; } + + private: + const std::string &mName; +}; + +inline std::ostream &operator<<(std::ostream &o, const DecorateVariable &dv) +{ + if (dv.getName().compare(0, 3, "gl_") != 0) + { + o << "_"; + } + o << dv.getName(); + return o; +} + +struct PixelShaderOutputVariable +{ + PixelShaderOutputVariable() {} + PixelShaderOutputVariable(GLenum typeIn, + const std::string &nameIn, + const std::string &sourceIn, + size_t outputLocationIn, + size_t outputIndexIn) + : type(typeIn), + name(nameIn), + source(sourceIn), + outputLocation(outputLocationIn), + outputIndex(outputIndexIn) + {} + + GLenum type = GL_NONE; + std::string name; + std::string source; + size_t outputLocation = 0; + size_t outputIndex = 0; +}; + +struct BuiltinVarying final : private angle::NonCopyable +{ + BuiltinVarying(); + + std::string str() const; + void enableSystem(const std::string &systemValueSemantic); + void enable(const std::string &semanticVal, unsigned int indexVal); + + bool enabled; + std::string semantic; + unsigned int index; + bool systemValue; +}; + +struct BuiltinInfo +{ + BuiltinInfo(); + ~BuiltinInfo(); + + BuiltinVarying dxPosition; + BuiltinVarying glPosition; + BuiltinVarying glFragCoord; + BuiltinVarying glPointCoord; + BuiltinVarying glPointSize; + BuiltinVarying glViewIDOVR; + BuiltinVarying glViewportIndex; + BuiltinVarying glLayer; +}; + +inline std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize) +{ + // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord) + // In D3D11 we manually compute gl_PointCoord in the GS. + return ((programUsesPointSize && majorShaderModel < 4) ? "COLOR" : "TEXCOORD"); +} + +class BuiltinVaryingsD3D +{ + public: + BuiltinVaryingsD3D(const ProgramD3DMetadata &metadata, const gl::VaryingPacking &packing); + ~BuiltinVaryingsD3D(); + + bool usesPointSize() const { return mBuiltinInfo[gl::ShaderType::Vertex].glPointSize.enabled; } + + const BuiltinInfo &operator[](gl::ShaderType shaderType) const + { + return mBuiltinInfo[shaderType]; + } + BuiltinInfo &operator[](gl::ShaderType shaderType) { return mBuiltinInfo[shaderType]; } + + private: + void updateBuiltins(gl::ShaderType shaderType, + const ProgramD3DMetadata &metadata, + const gl::VaryingPacking &packing); + + gl::ShaderMap<BuiltinInfo> mBuiltinInfo; +}; + +class DynamicHLSL : angle::NonCopyable +{ + public: + explicit DynamicHLSL(RendererD3D *const renderer); + + std::string generateVertexShaderForInputLayout( + const std::string &sourceShader, + const gl::InputLayout &inputLayout, + const std::vector<sh::ShaderVariable> &shaderAttributes, + const std::vector<rx::ShaderStorageBlock> &shaderStorageBlocks, + size_t baseUAVRegister) const; + std::string generatePixelShaderForOutputSignature( + const std::string &sourceShader, + const std::vector<PixelShaderOutputVariable> &outputVariables, + bool usesFragDepth, + const std::vector<GLenum> &outputLayout, + const std::vector<rx::ShaderStorageBlock> &shaderStorageBlocks, + size_t baseUAVRegister) const; + std::string generateShaderForImage2DBindSignature( + ProgramD3D &programD3D, + const gl::ProgramState &programData, + gl::ShaderType shaderType, + const std::string &shaderHLSL, + std::vector<sh::ShaderVariable> &image2DUniforms, + const gl::ImageUnitTextureTypeMap &image2DBindLayout, + unsigned int baseUAVRegister) const; + void generateShaderLinkHLSL(const gl::Context *context, + const gl::Caps &caps, + const gl::ProgramState &programData, + const ProgramD3DMetadata &programMetadata, + const gl::VaryingPacking &varyingPacking, + const BuiltinVaryingsD3D &builtinsD3D, + gl::ShaderMap<std::string> *shaderHLSL) const; + + std::string generateGeometryShaderPreamble(const gl::VaryingPacking &varyingPacking, + const BuiltinVaryingsD3D &builtinsD3D, + const bool hasANGLEMultiviewEnabled, + const bool selectViewInVS) const; + + std::string generateGeometryShaderHLSL(const gl::Caps &caps, + gl::PrimitiveMode primitiveType, + const gl::ProgramState &programData, + const bool useViewScale, + const bool hasANGLEMultiviewEnabled, + const bool selectViewInVS, + const bool pointSpriteEmulation, + const std::string &preambleString) const; + + void getPixelShaderOutputKey(const gl::State &data, + const gl::ProgramState &programData, + const ProgramD3DMetadata &metadata, + std::vector<PixelShaderOutputVariable> *outPixelShaderKey); + + private: + RendererD3D *const mRenderer; + + void generateVaryingLinkHLSL(const gl::VaryingPacking &varyingPacking, + const BuiltinInfo &builtins, + bool programUsesPointSize, + std::ostringstream &hlslStream) const; + + static void GenerateAttributeConversionHLSL(angle::FormatID vertexFormatID, + const sh::ShaderVariable &shaderAttrib, + std::ostringstream &outStream); +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.cpp new file mode 100644 index 0000000000..cf775d0b46 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.cpp @@ -0,0 +1,919 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DynamicImage2DHLSL.cpp: Implementation for link and run-time HLSL generation +// + +#include "libANGLE/renderer/d3d/DynamicImage2DHLSL.h" + +#include "common/string_utils.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" + +using namespace gl; + +namespace rx +{ + +namespace +{ + +enum Image2DHLSLGroup +{ + IMAGE2D_R_FLOAT4, + IMAGE2D_MIN = IMAGE2D_R_FLOAT4, + IMAGE2D_R_UNORM, + IMAGE2D_R_SNORM, + IMAGE2D_R_UINT4, + IMAGE2D_R_INT4, + IMAGE2D_W_FLOAT4, + IMAGE2D_W_UNORM, + IMAGE2D_W_SNORM, + IMAGE2D_W_UINT4, + IMAGE2D_W_INT4, + IMAGE2D_UNKNOWN, + IMAGE2D_MAX = IMAGE2D_UNKNOWN +}; + +enum Image2DMethod +{ + IMAGE2DSIZE, + IMAGE2DLOAD, + IMAGE2DSTORE +}; + +Image2DHLSLGroup image2DHLSLGroup(const sh::ShaderVariable &uniform) +{ + GLenum format = uniform.imageUnitFormat; + bool readonly = uniform.readonly; + switch (uniform.type) + { + case GL_IMAGE_2D: + { + switch (format) + { + case GL_RGBA32F: + case GL_RGBA16F: + case GL_R32F: + return readonly ? IMAGE2D_R_FLOAT4 : IMAGE2D_W_FLOAT4; + case GL_RGBA8: + return readonly ? IMAGE2D_R_UNORM : IMAGE2D_W_UNORM; + case GL_RGBA8_SNORM: + return readonly ? IMAGE2D_R_SNORM : IMAGE2D_W_SNORM; + default: + UNREACHABLE(); + return IMAGE2D_UNKNOWN; + } + } + case GL_INT_IMAGE_2D: + { + switch (format) + { + case GL_RGBA32I: + case GL_RGBA16I: + case GL_RGBA8I: + case GL_R32I: + return readonly ? IMAGE2D_R_INT4 : IMAGE2D_W_INT4; + default: + UNREACHABLE(); + return IMAGE2D_UNKNOWN; + } + } + case GL_UNSIGNED_INT_IMAGE_2D: + { + switch (format) + { + case GL_RGBA32UI: + case GL_RGBA16UI: + case GL_RGBA8UI: + case GL_R32UI: + return readonly ? IMAGE2D_R_UINT4 : IMAGE2D_W_UINT4; + default: + UNREACHABLE(); + return IMAGE2D_UNKNOWN; + } + } + default: + UNREACHABLE(); + return IMAGE2D_UNKNOWN; + } +} + +std::string Image2DHLSLGroupSuffix(Image2DHLSLGroup group) +{ + switch (group) + { + case IMAGE2D_R_FLOAT4: + return "2D"; + case IMAGE2D_R_UNORM: + return "2D_unorm_float4_"; + case IMAGE2D_R_SNORM: + return "2D_snorm_float4_"; + case IMAGE2D_R_UINT4: + return "2D_uint4_"; + case IMAGE2D_R_INT4: + return "2D_int4_"; + case IMAGE2D_W_FLOAT4: + return "RW2D_float4_"; + case IMAGE2D_W_UNORM: + return "RW2D_unorm_float4_"; + case IMAGE2D_W_SNORM: + return "RW2D_snorm_float4_"; + case IMAGE2D_W_UINT4: + return "RW2D_uint4_"; + case IMAGE2D_W_INT4: + return "RW2D_int4_"; + default: + UNREACHABLE(); + } + + return "<unknown group type>"; +} + +std::string Image2DHLSLTextureString(Image2DHLSLGroup group, + gl::TextureType type, + bool rasterOrdered) +{ + std::string textureString; + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + break; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + textureString += rasterOrdered ? "RasterizerOrdered" : "RW"; + break; + default: + UNREACHABLE(); + } + + textureString += "Texture"; + + switch (type) + { + case gl::TextureType::_2D: + textureString += "2D"; + break; + case gl::TextureType::_3D: + textureString += "3D"; + break; + case gl::TextureType::_2DArray: + textureString += "2DArray"; + break; + default: + UNREACHABLE(); + } + + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_W_FLOAT4: + textureString += "<float4>"; + break; + case IMAGE2D_R_UNORM: + case IMAGE2D_W_UNORM: + textureString += "<unorm float4>"; + break; + case IMAGE2D_R_SNORM: + case IMAGE2D_W_SNORM: + textureString += "<snorm float4>"; + break; + case IMAGE2D_R_UINT4: + case IMAGE2D_W_UINT4: + textureString += "<uint4>"; + break; + case IMAGE2D_R_INT4: + case IMAGE2D_W_INT4: + textureString += "<int4>"; + break; + default: + UNREACHABLE(); + } + + return textureString; +} + +std::string Image2DHLSLGroupOffsetPrefix(Image2DHLSLGroup group) +{ + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + return "readonlyImageIndexOffset"; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + return "imageIndexOffset"; + default: + UNREACHABLE(); + } + + return "<unknown group type>"; +} + +std::string Image2DHLSLGroupDeclarationPrefix(Image2DHLSLGroup group) +{ + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + return "readonlyImages"; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + return "images"; + default: + UNREACHABLE(); + } + + return "<unknown group type>"; +} + +std::string Image2DHLSLGroupRegisterSuffix(Image2DHLSLGroup group) +{ + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + return "t"; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + return "u"; + default: + UNREACHABLE(); + } + + return "<unknown group type>"; +} + +std::string Image2DHLSLGroupFunctionName(Image2DHLSLGroup group, Image2DMethod method) +{ + std::string name = "gl_image"; + name += Image2DHLSLGroupSuffix(group); + switch (method) + { + case IMAGE2DSIZE: + name += "Size"; + break; + case IMAGE2DLOAD: + name += "Load"; + break; + case IMAGE2DSTORE: + name += "Store"; + break; + default: + UNREACHABLE(); + } + + return name; +} + +std::string getImage2DGroupReturnType(Image2DHLSLGroup group, Image2DMethod method) +{ + switch (method) + { + case IMAGE2DSIZE: + return "int2"; + case IMAGE2DLOAD: + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + return "float4"; + case IMAGE2D_R_UINT4: + case IMAGE2D_W_UINT4: + return "uint4"; + case IMAGE2D_R_INT4: + case IMAGE2D_W_INT4: + return "int4"; + default: + UNREACHABLE(); + return "unknown group type"; + } + case IMAGE2DSTORE: + return "void"; + default: + UNREACHABLE(); + return "unknown image method"; + } +} + +std::string getImageMetadata(Image2DHLSLGroup group) +{ + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + return "readonlyImageMetadata[imageIndex - readonlyImageIndexStart]"; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + return "imageMetadata[imageIndex - imageIndexStart]"; + default: + UNREACHABLE(); + return "unknown image method"; + } +} + +void OutputImage2DFunctionArgumentList(std::ostringstream &out, + Image2DHLSLGroup group, + Image2DMethod method) +{ + out << "uint imageIndex"; + + if (method == IMAGE2DLOAD || method == IMAGE2DSTORE) + { + out << ", int2 p"; + if (method == IMAGE2DSTORE) + { + switch (group) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + out << ", float4 data"; + break; + case IMAGE2D_R_UINT4: + case IMAGE2D_W_UINT4: + out << ", uint4 data"; + break; + case IMAGE2D_R_INT4: + case IMAGE2D_W_INT4: + out << ", int4 data"; + break; + default: + UNREACHABLE(); + } + } + } +} + +void OutputImage2DSizeFunction(std::ostringstream &out, + Image2DHLSLGroup textureGroup, + unsigned int totalCount, + unsigned int texture2DCount, + unsigned int texture3DCount, + unsigned int texture2DArrayCount, + const std::string &offsetStr, + const std::string &declarationStr) +{ + out << getImage2DGroupReturnType(textureGroup, IMAGE2DSIZE) << " " + << Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DSIZE) << "("; + OutputImage2DFunctionArgumentList(out, textureGroup, IMAGE2DSIZE); + out << ")\n" + "{\n"; + out << " uint width, height;\n"; + + if (texture2DCount > 0) + { + if (texture2DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " " << declarationStr << "2D[index].GetDimensions(width, height);\n"; + } + else + { + out << " if (imageIndex >= " << offsetStr << "2D && imageIndex < " << offsetStr + << "2D + " << texture2DCount << ")\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " " << declarationStr << "2D[index].GetDimensions(width, height);\n"; + out << " }\n"; + } + } + + if (texture3DCount > 0) + { + if (texture3DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " uint depth;\n"; + out << " " << declarationStr << "3D[index].GetDimensions(width, height, depth);\n"; + } + else + { + if (texture2DArrayCount == 0) + { + out << " else\n"; + } + else + { + if (texture2DCount == 0) + { + out << " if "; + } + else + { + out << " else if"; + } + out << "(imageIndex >= " << offsetStr << "3D && imageIndex < " << offsetStr + << "3D + " << texture3DCount << ")\n"; + } + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " uint depth;\n"; + out << " " << declarationStr + << "3D[index].GetDimensions(width, height, depth);\n"; + out << " }\n"; + } + } + + if (texture2DArrayCount > 0) + { + if (texture2DArrayCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " uint depth;\n"; + out << " " << declarationStr + << "2DArray[index].GetDimensions(width, height, depth);\n"; + } + else + { + out << " else\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " uint depth;\n"; + out << " " << declarationStr + << "2DArray[index].GetDimensions(width, height, depth);\n"; + out << " }\n"; + } + } + out << " return int2(width, height);\n"; + + out << "}\n"; +} + +void OutputImage2DLoadFunction(std::ostringstream &out, + Image2DHLSLGroup textureGroup, + unsigned int totalCount, + unsigned int texture2DCount, + unsigned int texture3DCount, + unsigned int texture2DArrayCount, + const std::string &offsetStr, + const std::string &declarationStr) +{ + out << getImage2DGroupReturnType(textureGroup, IMAGE2DLOAD) << " " + << Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DLOAD) << "("; + OutputImage2DFunctionArgumentList(out, textureGroup, IMAGE2DLOAD); + out << ")\n" + "{\n"; + + out << " " << getImage2DGroupReturnType(textureGroup, IMAGE2DLOAD) << " result;\n"; + + if (texture2DCount > 0) + { + if (texture2DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " result = " << declarationStr << "2D[index][uint2(p.x, p.y)];\n"; + } + else + { + out << " if (imageIndex >= " << offsetStr << "2D && imageIndex < " << offsetStr + << "2D + " << texture2DCount << ")\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " result = " << declarationStr << "2D[index][uint2(p.x, p.y)];\n"; + out << " }\n"; + } + } + + if (texture3DCount > 0) + { + if (texture3DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " result = " << declarationStr << "3D[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)];\n"; + } + else + { + if (texture2DArrayCount == 0) + { + out << " else\n"; + } + else + { + if (texture2DCount == 0) + { + out << " if "; + } + else + { + out << " else if"; + } + out << "(imageIndex >= " << offsetStr << "3D && imageIndex < " << offsetStr + << "3D + " << texture3DCount << ")\n"; + } + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " result = " << declarationStr << "3D[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)];\n"; + out << " }\n"; + } + } + + if (texture2DArrayCount > 0) + { + if (texture2DArrayCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " result = " << declarationStr << "2DArray[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)];\n"; + } + else + { + out << " else\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " result = " << declarationStr << "2DArray[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)];\n"; + out << " }\n"; + } + } + + out << " return result;\n"; + out << "}\n"; +} + +void OutputImage2DStoreFunction(std::ostringstream &out, + Image2DHLSLGroup textureGroup, + unsigned int totalCount, + unsigned int texture2DCount, + unsigned int texture3DCount, + unsigned int texture2DArrayCount, + const std::string &offsetStr, + const std::string &declarationStr) +{ + out << getImage2DGroupReturnType(textureGroup, IMAGE2DSTORE) << " " + << Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DSTORE) << "("; + OutputImage2DFunctionArgumentList(out, textureGroup, IMAGE2DSTORE); + out << ")\n" + "{\n"; + + if (texture2DCount > 0) + { + if (texture2DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " " << declarationStr << "2D[index][uint2(p.x, p.y)] = data;\n"; + } + else + { + out << " if (imageIndex >= " << offsetStr << "2D && imageIndex < " << offsetStr + << "2D + " << texture2DCount << ")\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2D;\n"; + out << " " << declarationStr << "2D[index][uint2(p.x, p.y)] = data;\n"; + out << " }\n"; + } + } + + if (texture3DCount > 0) + { + if (texture3DCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " " << declarationStr << "3D[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)] = data;\n"; + } + else + { + if (texture2DArrayCount == 0) + { + out << " else\n"; + } + else + { + if (texture2DCount == 0) + { + out << " if "; + } + else + { + out << " else if"; + } + out << "(imageIndex >= " << offsetStr << "3D && imageIndex < " << offsetStr + << "3D + " << texture3DCount << ")\n"; + } + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "3D;\n"; + out << " " << declarationStr << "3D[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)] = data;\n"; + out << " }\n"; + } + } + + if (texture2DArrayCount > 0) + { + if (texture2DArrayCount == totalCount) + { + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " " << declarationStr << "2DArray[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)] = data;\n"; + } + else + { + out << " else\n"; + out << " {\n"; + out << " const uint index = imageIndex - " << offsetStr << "2DArray;\n"; + out << " " << declarationStr << "2DArray[index][uint3(p.x, p.y, " + << getImageMetadata(textureGroup) << ".layer)] = data;\n"; + out << " }\n"; + } + } + + out << "}\n"; +} + +unsigned int *GetImage2DRegisterIndex(Image2DHLSLGroup textureGroup, + unsigned int *groupTextureRegisterIndex, + unsigned int *groupRWTextureRegisterIndex) +{ + switch (textureGroup) + { + case IMAGE2D_R_FLOAT4: + case IMAGE2D_R_UNORM: + case IMAGE2D_R_SNORM: + case IMAGE2D_R_UINT4: + case IMAGE2D_R_INT4: + return groupTextureRegisterIndex; + case IMAGE2D_W_FLOAT4: + case IMAGE2D_W_UNORM: + case IMAGE2D_W_SNORM: + case IMAGE2D_W_UINT4: + case IMAGE2D_W_INT4: + return groupRWTextureRegisterIndex; + default: + UNREACHABLE(); + return nullptr; + } +} + +void OutputHLSLImage2DUniformGroup(ProgramD3D &programD3D, + const gl::ProgramState &programData, + gl::ShaderType shaderType, + std::ostringstream &out, + const Image2DHLSLGroup textureGroup, + const std::vector<sh::ShaderVariable> &group, + const gl::ImageUnitTextureTypeMap &image2DBindLayout, + unsigned int baseUAVRegister, + unsigned int *groupTextureRegisterIndex, + unsigned int *groupRWTextureRegisterIndex, + unsigned int *image2DTexture3D, + unsigned int *image2DTexture2DArray, + unsigned int *image2DTexture2D) +{ + if (group.empty()) + { + return; + } + + unsigned int texture2DCount = 0, texture3DCount = 0, texture2DArrayCount = 0; + bool texture2DRasterOrdered = false, texture3DRasterOrdered = false, + texture2DArrayRasterOrdered = false; + for (const sh::ShaderVariable &uniform : group) + { + if (!programD3D.hasNamedUniform(uniform.name)) + { + continue; + } + for (unsigned int index = 0; index < uniform.getArraySizeProduct(); index++) + { + switch (image2DBindLayout.at(uniform.binding + index)) + { + case gl::TextureType::_2D: + texture2DCount++; + texture2DRasterOrdered |= uniform.rasterOrdered; + break; + case gl::TextureType::_3D: + texture3DCount++; + texture3DRasterOrdered |= uniform.rasterOrdered; + break; + case gl::TextureType::_2DArray: + case gl::TextureType::CubeMap: + texture2DArrayCount++; + texture2DArrayRasterOrdered |= uniform.rasterOrdered; + break; + default: + UNREACHABLE(); + } + } + } + + unsigned int totalCount = texture2DCount + texture3DCount + texture2DArrayCount; + unsigned int *image2DRegisterIndex = GetImage2DRegisterIndex( + textureGroup, groupTextureRegisterIndex, groupRWTextureRegisterIndex); + unsigned int texture2DRegisterIndex = *image2DRegisterIndex; + unsigned int texture3DRegisterIndex = texture2DRegisterIndex + texture2DCount; + unsigned int texture2DArrayRegisterIndex = texture3DRegisterIndex + texture3DCount; + *image2DRegisterIndex += totalCount; + + std::string offsetStr = + Image2DHLSLGroupOffsetPrefix(textureGroup) + Image2DHLSLGroupSuffix(textureGroup); + std::string declarationStr = + Image2DHLSLGroupDeclarationPrefix(textureGroup) + Image2DHLSLGroupSuffix(textureGroup); + std::string registerStr = Image2DHLSLGroupRegisterSuffix(textureGroup); + if (texture2DCount > 0) + { + out << "static const uint " << offsetStr << "2D = " << texture2DRegisterIndex << ";\n"; + out << "uniform " + << Image2DHLSLTextureString(textureGroup, gl::TextureType::_2D, texture2DRasterOrdered) + << " " << declarationStr << "2D[" << texture2DCount << "]" + << " : register(" << registerStr << baseUAVRegister + texture2DRegisterIndex << ");\n"; + } + if (texture3DCount > 0) + { + out << "static const uint " << offsetStr << "3D = " << texture3DRegisterIndex << ";\n"; + out << "uniform " + << Image2DHLSLTextureString(textureGroup, gl::TextureType::_3D, texture3DRasterOrdered) + << " " << declarationStr << "3D[" << texture3DCount << "]" + << " : register(" << registerStr << baseUAVRegister + texture3DRegisterIndex << ");\n"; + } + if (texture2DArrayCount > 0) + { + out << "static const uint " << offsetStr << "2DArray = " << texture2DArrayRegisterIndex + << ";\n"; + out << "uniform " + << Image2DHLSLTextureString(textureGroup, gl::TextureType::_2DArray, + texture2DArrayRasterOrdered) + << " " << declarationStr << "2DArray[" << texture2DArrayCount << "]" + << " : register(" << registerStr << baseUAVRegister + texture2DArrayRegisterIndex + << ");\n"; + } + for (const sh::ShaderVariable &uniform : group) + { + if (!programD3D.hasNamedUniform(uniform.name)) + { + continue; + } + + out << "static const uint " << DecorateVariable(uniform.name) + << ArrayIndexString(uniform.arraySizes) << " = {"; + for (unsigned int index = 0; index < uniform.getArraySizeProduct(); index++) + { + if (index > 0) + { + out << ", "; + } + switch (image2DBindLayout.at(uniform.binding + index)) + { + case gl::TextureType::_2D: + { + out << texture2DRegisterIndex; + programD3D.assignImage2DRegisters(shaderType, texture2DRegisterIndex, + uniform.binding + index, uniform.readonly); + texture2DRegisterIndex++; + break; + } + case gl::TextureType::_3D: + { + out << texture3DRegisterIndex; + programD3D.assignImage2DRegisters(shaderType, texture3DRegisterIndex, + uniform.binding + index, uniform.readonly); + texture3DRegisterIndex++; + break; + } + case gl::TextureType::_2DArray: + case gl::TextureType::CubeMap: + { + out << texture2DArrayRegisterIndex; + programD3D.assignImage2DRegisters(shaderType, texture2DArrayRegisterIndex, + uniform.binding + index, uniform.readonly); + texture2DArrayRegisterIndex++; + break; + } + default: + UNREACHABLE(); + } + } + out << "};\n"; + } + + gl::Shader *shaderGL = programData.getAttachedShader(shaderType); + const ShaderD3D *shaderD3D = GetImplAs<ShaderD3D>(shaderGL); + + if (shaderD3D->useImage2DFunction(Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DSIZE))) + { + OutputImage2DSizeFunction(out, textureGroup, totalCount, texture2DCount, texture3DCount, + texture2DArrayCount, offsetStr, declarationStr); + } + if (shaderD3D->useImage2DFunction(Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DLOAD))) + { + OutputImage2DLoadFunction(out, textureGroup, totalCount, texture2DCount, texture3DCount, + texture2DArrayCount, offsetStr, declarationStr); + } + if (shaderD3D->useImage2DFunction(Image2DHLSLGroupFunctionName(textureGroup, IMAGE2DSTORE))) + { + OutputImage2DStoreFunction(out, textureGroup, totalCount, texture2DCount, texture3DCount, + texture2DArrayCount, offsetStr, declarationStr); + } +} + +// kImage2DFunctionString must be the same as outputHLSL. +constexpr const char kImage2DFunctionString[] = "// @@ IMAGE2D DECLARATION FUNCTION STRING @@"; +} // anonymous namespace + +std::string GenerateShaderForImage2DBindSignature( + ProgramD3D &programD3D, + const gl::ProgramState &programData, + gl::ShaderType shaderType, + const std::string &shaderHLSL, + std::vector<sh::ShaderVariable> &image2DUniforms, + const gl::ImageUnitTextureTypeMap &image2DBindLayout, + unsigned int baseUAVRegister) +{ + std::vector<std::vector<sh::ShaderVariable>> groupedImage2DUniforms(IMAGE2D_MAX + 1); + unsigned int image2DTexture3DCount = 0, image2DTexture2DArrayCount = 0; + for (sh::ShaderVariable &image2D : image2DUniforms) + { + for (unsigned int index = 0; index < image2D.getArraySizeProduct(); index++) + { + // Any image variable declared without a binding qualifier is initially bound to unit + // zero. + if (image2D.binding == -1) + { + image2D.binding = 0; + } + switch (image2DBindLayout.at(image2D.binding + index)) + { + case gl::TextureType::_2D: + break; + case gl::TextureType::_3D: + image2DTexture3DCount++; + break; + case gl::TextureType::_2DArray: + case gl::TextureType::CubeMap: + image2DTexture2DArrayCount++; + break; + default: + UNREACHABLE(); + } + } + Image2DHLSLGroup group = image2DHLSLGroup(image2D); + groupedImage2DUniforms[group].push_back(image2D); + } + + gl::Shader *shaderGL = programData.getAttachedShader(shaderType); + const ShaderD3D *shaderD3D = GetImplAs<ShaderD3D>(shaderGL); + unsigned int groupTextureRegisterIndex = shaderD3D->getReadonlyImage2DRegisterIndex(); + unsigned int groupRWTextureRegisterIndex = shaderD3D->getImage2DRegisterIndex(); + unsigned int image2DTexture3DIndex = 0; + unsigned int image2DTexture2DArrayIndex = image2DTexture3DCount; + unsigned int image2DTexture2DIndex = image2DTexture3DCount + image2DTexture2DArrayCount; + std::ostringstream out; + + for (int groupId = IMAGE2D_MIN; groupId < IMAGE2D_MAX; ++groupId) + { + OutputHLSLImage2DUniformGroup( + programD3D, programData, shaderType, out, Image2DHLSLGroup(groupId), + groupedImage2DUniforms[groupId], image2DBindLayout, baseUAVRegister, + &groupTextureRegisterIndex, &groupRWTextureRegisterIndex, &image2DTexture3DIndex, + &image2DTexture2DArrayIndex, &image2DTexture2DIndex); + } + + std::string result = shaderHLSL; + bool success = angle::ReplaceSubstring(&result, kImage2DFunctionString, out.str()); + ASSERT(success); + + return result; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.h new file mode 100644 index 0000000000..6533c972f8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/DynamicImage2DHLSL.h @@ -0,0 +1,28 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DynamicImage2DHLSL.h: Interface for link and run-time HLSL generation +// + +#ifndef LIBANGLE_RENDERER_D3D_DYNAMICIMAGE2DHLSL_H_ +#define LIBANGLE_RENDERER_D3D_DYNAMICIMAGE2DHLSL_H_ + +#include "common/angleutils.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ +std::string GenerateShaderForImage2DBindSignature( + ProgramD3D &programD3D, + const gl::ProgramState &programData, + gl::ShaderType shaderType, + const std::string &shaderHLSL, + std::vector<sh::ShaderVariable> &image2DUniforms, + const gl::ImageUnitTextureTypeMap &image2DBindLayout, + unsigned int baseUAVRegister); + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.cpp new file mode 100644 index 0000000000..c2ff39ba24 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.cpp @@ -0,0 +1,93 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// EGLImageD3D.cpp: Implements the rx::EGLImageD3D class, the D3D implementation of EGL images + +#include "libANGLE/renderer/d3d/EGLImageD3D.h" + +#include "common/debug.h" +#include "common/utilities.h" +#include "libANGLE/AttributeMap.h" +#include "libANGLE/Context.h" +#include "libANGLE/Texture.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/TextureStorage.h" + +#include <EGL/eglext.h> + +namespace rx +{ + +EGLImageD3D::EGLImageD3D(const egl::ImageState &state, + EGLenum target, + const egl::AttributeMap &attribs, + RendererD3D *renderer) + : ImageImpl(state), mRenderer(renderer), mRenderTarget(nullptr) +{ + ASSERT(renderer != nullptr); +} + +EGLImageD3D::~EGLImageD3D() +{ + SafeDelete(mRenderTarget); +} + +egl::Error EGLImageD3D::initialize(const egl::Display *display) +{ + return egl::NoError(); +} + +angle::Result EGLImageD3D::orphan(const gl::Context *context, egl::ImageSibling *sibling) +{ + if (sibling == mState.source) + { + ANGLE_TRY(copyToLocalRendertarget(context)); + } + + return angle::Result::Continue; +} + +angle::Result EGLImageD3D::getRenderTarget(const gl::Context *context, + RenderTargetD3D **outRT) const +{ + if (mState.source != nullptr) + { + ASSERT(!mRenderTarget); + FramebufferAttachmentRenderTarget *rt = nullptr; + ANGLE_TRY( + mState.source->getAttachmentRenderTarget(context, GL_NONE, mState.imageIndex, 0, &rt)); + *outRT = static_cast<RenderTargetD3D *>(rt); + return angle::Result::Continue; + } + + ASSERT(mRenderTarget); + *outRT = mRenderTarget; + return angle::Result::Continue; +} + +angle::Result EGLImageD3D::copyToLocalRendertarget(const gl::Context *context) +{ + ASSERT(mState.source != nullptr); + ASSERT(mRenderTarget == nullptr); + + RenderTargetD3D *curRenderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, &curRenderTarget)); + + { + std::unique_lock lock(mState.targetsLock); + // Invalidate FBOs with this Image attached. Only currently applies to D3D11. + for (egl::ImageSibling *target : mState.targets) + { + target->onStateChange(angle::SubjectMessage::SubjectChanged); + } + } + + return mRenderer->createRenderTargetCopy(context, curRenderTarget, &mRenderTarget); +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.h new file mode 100644 index 0000000000..53c18739af --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/EGLImageD3D.h @@ -0,0 +1,55 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// EGLImageD3D.h: Defines the rx::EGLImageD3D class, the D3D implementation of EGL images + +#ifndef LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_ +#define LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_ + +#include "libANGLE/renderer/ImageImpl.h" + +namespace gl +{ +class Context; +} + +namespace egl +{ +class AttributeMap; +} + +namespace rx +{ +class FramebufferAttachmentObjectImpl; +class TextureD3D; +class RenderbufferD3D; +class RendererD3D; +class RenderTargetD3D; + +class EGLImageD3D final : public ImageImpl +{ + public: + EGLImageD3D(const egl::ImageState &state, + EGLenum target, + const egl::AttributeMap &attribs, + RendererD3D *renderer); + ~EGLImageD3D() override; + + egl::Error initialize(const egl::Display *display) override; + + angle::Result orphan(const gl::Context *context, egl::ImageSibling *sibling) override; + + angle::Result getRenderTarget(const gl::Context *context, RenderTargetD3D **outRT) const; + + private: + angle::Result copyToLocalRendertarget(const gl::Context *context); + + RendererD3D *mRenderer; + RenderTargetD3D *mRenderTarget; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.cpp new file mode 100644 index 0000000000..5a8279a586 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.cpp @@ -0,0 +1,402 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// FramebufferD3D.cpp: Implements the DefaultAttachmentD3D and FramebufferD3D classes. + +#include "libANGLE/renderer/d3d/FramebufferD3D.h" + +#include "common/bitset_utils.h" +#include "libANGLE/Context.h" +#include "libANGLE/ErrorStrings.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Surface.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/SurfaceD3D.h" +#include "libANGLE/renderer/d3d/SwapChainD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" + +namespace rx +{ + +namespace +{ + +ClearParameters GetClearParameters(const gl::State &state, GLbitfield mask) +{ + ClearParameters clearParams; + memset(&clearParams, 0, sizeof(ClearParameters)); + + clearParams.colorF = state.getColorClearValue(); + clearParams.colorType = GL_FLOAT; + clearParams.clearDepth = false; + clearParams.depthValue = state.getDepthClearValue(); + clearParams.clearStencil = false; + clearParams.stencilValue = state.getStencilClearValue(); + clearParams.stencilWriteMask = state.getDepthStencilState().stencilWritemask; + + const auto *framebufferObject = state.getDrawFramebuffer(); + const gl::Extents &framebufferSize = framebufferObject->getFirstNonNullAttachment()->getSize(); + const gl::Offset &surfaceTextureOffset = framebufferObject->getSurfaceTextureOffset(); + if (state.isScissorTestEnabled()) + { + clearParams.scissorEnabled = true; + clearParams.scissor = state.getScissor(); + clearParams.scissor.x = clearParams.scissor.x + surfaceTextureOffset.x; + clearParams.scissor.y = clearParams.scissor.y + surfaceTextureOffset.y; + } + else if (surfaceTextureOffset != gl::kOffsetZero) + { + clearParams.scissorEnabled = true; + clearParams.scissor = gl::Rectangle(surfaceTextureOffset.x, surfaceTextureOffset.y, + framebufferSize.width, framebufferSize.height); + } + + const bool clearColor = + (mask & GL_COLOR_BUFFER_BIT) && framebufferObject->hasEnabledDrawBuffer(); + if (clearColor) + { + clearParams.clearColor.set(); + } + else + { + clearParams.clearColor.reset(); + } + clearParams.colorMask = state.getBlendStateExt().getColorMaskBits(); + + if (mask & GL_DEPTH_BUFFER_BIT) + { + if (state.getDepthStencilState().depthMask && + framebufferObject->getDepthAttachment() != nullptr) + { + clearParams.clearDepth = true; + } + } + + if (mask & GL_STENCIL_BUFFER_BIT) + { + if (framebufferObject->getStencilAttachment() != nullptr && + framebufferObject->getStencilAttachment()->getStencilSize() > 0) + { + clearParams.clearStencil = true; + } + } + + return clearParams; +} +} // namespace + +ClearParameters::ClearParameters() = default; + +ClearParameters::ClearParameters(const ClearParameters &other) = default; + +FramebufferD3D::FramebufferD3D(const gl::FramebufferState &data, RendererD3D *renderer) + : FramebufferImpl(data), mRenderer(renderer), mMockAttachment() +{} + +FramebufferD3D::~FramebufferD3D() {} + +angle::Result FramebufferD3D::clear(const gl::Context *context, GLbitfield mask) +{ + ClearParameters clearParams = GetClearParameters(context->getState(), mask); + return clearImpl(context, clearParams); +} + +angle::Result FramebufferD3D::clearBufferfv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLfloat *values) +{ + // glClearBufferfv can be called to clear the color buffer or depth buffer + ClearParameters clearParams = GetClearParameters(context->getState(), 0); + + if (buffer == GL_COLOR) + { + for (unsigned int i = 0; i < clearParams.clearColor.size(); i++) + { + clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); + } + clearParams.colorF = gl::ColorF(values[0], values[1], values[2], values[3]); + clearParams.colorType = GL_FLOAT; + } + + if (buffer == GL_DEPTH) + { + clearParams.clearDepth = true; + clearParams.depthValue = values[0]; + } + + return clearImpl(context, clearParams); +} + +angle::Result FramebufferD3D::clearBufferuiv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLuint *values) +{ + // glClearBufferuiv can only be called to clear a color buffer + ClearParameters clearParams = GetClearParameters(context->getState(), 0); + for (unsigned int i = 0; i < clearParams.clearColor.size(); i++) + { + clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); + } + clearParams.colorUI = gl::ColorUI(values[0], values[1], values[2], values[3]); + clearParams.colorType = GL_UNSIGNED_INT; + + return clearImpl(context, clearParams); +} + +angle::Result FramebufferD3D::clearBufferiv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLint *values) +{ + // glClearBufferiv can be called to clear the color buffer or stencil buffer + ClearParameters clearParams = GetClearParameters(context->getState(), 0); + + if (buffer == GL_COLOR) + { + for (unsigned int i = 0; i < clearParams.clearColor.size(); i++) + { + clearParams.clearColor[i] = (drawbuffer == static_cast<int>(i)); + } + clearParams.colorI = gl::ColorI(values[0], values[1], values[2], values[3]); + clearParams.colorType = GL_INT; + } + + if (buffer == GL_STENCIL) + { + clearParams.clearStencil = true; + clearParams.stencilValue = values[0]; + } + + return clearImpl(context, clearParams); +} + +angle::Result FramebufferD3D::clearBufferfi(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil) +{ + // glClearBufferfi can only be called to clear a depth stencil buffer + ClearParameters clearParams = GetClearParameters(context->getState(), 0); + clearParams.clearDepth = true; + clearParams.depthValue = depth; + clearParams.clearStencil = true; + clearParams.stencilValue = stencil; + + return clearImpl(context, clearParams); +} + +angle::Result FramebufferD3D::readPixels(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + void *pixels) +{ + // Clip read area to framebuffer. + const gl::Extents fbSize = getState().getReadPixelsAttachment(format)->getSize(); + const gl::Rectangle fbRect(0, 0, fbSize.width, fbSize.height); + gl::Rectangle clippedArea; + if (!ClipRectangle(area, fbRect, &clippedArea)) + { + // nothing to read + return angle::Result::Continue; + } + + const gl::InternalFormat &sizedFormatInfo = gl::GetInternalFormatInfo(format, type); + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + + GLuint outputPitch = 0; + ANGLE_CHECK_GL_MATH(contextD3D, + sizedFormatInfo.computeRowPitch(type, area.width, pack.alignment, + pack.rowLength, &outputPitch)); + + GLuint outputSkipBytes = 0; + ANGLE_CHECK_GL_MATH(contextD3D, sizedFormatInfo.computeSkipBytes(type, outputPitch, 0, pack, + false, &outputSkipBytes)); + outputSkipBytes += (clippedArea.x - area.x) * sizedFormatInfo.pixelBytes + + (clippedArea.y - area.y) * outputPitch; + + return readPixelsImpl(context, clippedArea, format, type, outputPitch, pack, packBuffer, + static_cast<uint8_t *>(pixels) + outputSkipBytes); +} + +angle::Result FramebufferD3D::blit(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + GLbitfield mask, + GLenum filter) +{ + const auto &glState = context->getState(); + const gl::Framebuffer *sourceFramebuffer = glState.getReadFramebuffer(); + const gl::Rectangle *scissor = glState.isScissorTestEnabled() ? &glState.getScissor() : nullptr; + ANGLE_TRY(blitImpl(context, sourceArea, destArea, scissor, (mask & GL_COLOR_BUFFER_BIT) != 0, + (mask & GL_DEPTH_BUFFER_BIT) != 0, (mask & GL_STENCIL_BUFFER_BIT) != 0, + filter, sourceFramebuffer)); + + return angle::Result::Continue; +} + +gl::FramebufferStatus FramebufferD3D::checkStatus(const gl::Context *context) const +{ + // if we have both a depth and stencil buffer, they must refer to the same object + // since we only support packed_depth_stencil and not separate depth and stencil + if (mState.hasSeparateDepthAndStencilAttachments()) + { + return gl::FramebufferStatus::Incomplete( + GL_FRAMEBUFFER_UNSUPPORTED, + gl::err::kFramebufferIncompleteUnsupportedSeparateDepthStencilBuffers); + } + + // D3D11 does not allow for overlapping RenderTargetViews. + // If WebGL compatibility is enabled, this has already been checked at a higher level. + ASSERT(!context->isWebGL() || mState.colorAttachmentsAreUniqueImages()); + if (!context->isWebGL()) + { + if (!mState.colorAttachmentsAreUniqueImages()) + { + return gl::FramebufferStatus::Incomplete( + GL_FRAMEBUFFER_UNSUPPORTED, + gl::err::kFramebufferIncompleteUnsupportedNonUniqueAttachments); + } + } + + // D3D requires all render targets to have the same dimensions. + if (!mState.attachmentsHaveSameDimensions()) + { + return gl::FramebufferStatus::Incomplete( + GL_FRAMEBUFFER_UNSUPPORTED, + gl::err::kFramebufferIncompleteUnsupportedMissmatchedDimensions); + } + + return gl::FramebufferStatus::Complete(); +} + +angle::Result FramebufferD3D::syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) +{ + if (!mColorAttachmentsForRender.valid()) + { + return angle::Result::Continue; + } + + for (auto dirtyBit : dirtyBits) + { + if ((dirtyBit >= gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0 && + dirtyBit < gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX) || + dirtyBit == gl::Framebuffer::DIRTY_BIT_DRAW_BUFFERS) + { + mColorAttachmentsForRender.reset(); + } + } + + return angle::Result::Continue; +} + +const gl::AttachmentList &FramebufferD3D::getColorAttachmentsForRender(const gl::Context *context) +{ + gl::DrawBufferMask activeProgramOutputs = + context->getState().getProgram()->getExecutable().getActiveOutputVariablesMask(); + + if (mColorAttachmentsForRender.valid() && mCurrentActiveProgramOutputs == activeProgramOutputs) + { + return mColorAttachmentsForRender.value(); + } + + // Does not actually free memory + gl::AttachmentList colorAttachmentsForRender; + mColorAttachmentsForRenderMask.reset(); + + const auto &colorAttachments = mState.getColorAttachments(); + const auto &drawBufferStates = mState.getDrawBufferStates(); + const auto &features = mRenderer->getFeatures(); + + for (size_t attachmentIndex = 0; attachmentIndex < colorAttachments.size(); ++attachmentIndex) + { + GLenum drawBufferState = drawBufferStates[attachmentIndex]; + const gl::FramebufferAttachment &colorAttachment = colorAttachments[attachmentIndex]; + + if (colorAttachment.isAttached() && drawBufferState != GL_NONE && + activeProgramOutputs[attachmentIndex]) + { + ASSERT(drawBufferState == GL_BACK || + drawBufferState == (GL_COLOR_ATTACHMENT0_EXT + attachmentIndex)); + colorAttachmentsForRender.push_back(&colorAttachment); + mColorAttachmentsForRenderMask.set(attachmentIndex); + } + else if (!features.mrtPerfWorkaround.enabled) + { + colorAttachmentsForRender.push_back(nullptr); + mColorAttachmentsForRenderMask.set(attachmentIndex); + } + } + + // When rendering with no render target on D3D, two bugs lead to incorrect behavior on Intel + // drivers < 4815. The rendering samples always pass neglecting discard statements in pixel + // shader. We add a mock texture as render target in such case. + if (mRenderer->getFeatures().addMockTextureNoRenderTarget.enabled && + colorAttachmentsForRender.empty() && activeProgramOutputs.any()) + { + static_assert(static_cast<size_t>(activeProgramOutputs.size()) <= 32, + "Size of active program outputs should less or equal than 32."); + const GLuint activeProgramLocation = static_cast<GLuint>( + gl::ScanForward(static_cast<uint32_t>(activeProgramOutputs.bits()))); + + if (mMockAttachment.isAttached() && + (mMockAttachment.getBinding() - GL_COLOR_ATTACHMENT0) == activeProgramLocation) + { + colorAttachmentsForRender.push_back(&mMockAttachment); + } + else + { + // Remove mock attachment to prevents us from leaking it, and the program may require + // it to be attached to a new binding point. + if (mMockAttachment.isAttached()) + { + mMockAttachment.detach(context, Serial()); + } + + gl::Texture *mockTex = nullptr; + // TODO(jmadill): Handle error if mock texture can't be created. + (void)mRenderer->getIncompleteTexture(context, gl::TextureType::_2D, &mockTex); + if (mockTex) + { + gl::ImageIndex index = gl::ImageIndex::Make2D(0); + mMockAttachment = gl::FramebufferAttachment( + context, GL_TEXTURE, GL_COLOR_ATTACHMENT0_EXT + activeProgramLocation, index, + mockTex, Serial()); + colorAttachmentsForRender.push_back(&mMockAttachment); + } + } + } + + mColorAttachmentsForRender = std::move(colorAttachmentsForRender); + mCurrentActiveProgramOutputs = activeProgramOutputs; + + return mColorAttachmentsForRender.value(); +} + +void FramebufferD3D::destroy(const gl::Context *context) +{ + if (mMockAttachment.isAttached()) + { + mMockAttachment.detach(context, Serial()); + } +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.h new file mode 100644 index 0000000000..67e19bd4bc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/FramebufferD3D.h @@ -0,0 +1,143 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// FramebufferD3D.h: Defines the DefaultAttachmentD3D and FramebufferD3D classes. + +#ifndef LIBANGLE_RENDERER_D3D_FRAMBUFFERD3D_H_ +#define LIBANGLE_RENDERER_D3D_FRAMBUFFERD3D_H_ + +#include <cstdint> +#include <vector> + +#include "common/Color.h" +#include "common/Optional.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/FramebufferImpl.h" + +namespace gl +{ +class FramebufferAttachment; +struct PixelPackState; + +typedef std::vector<const FramebufferAttachment *> AttachmentList; +} // namespace gl + +namespace rx +{ +class RendererD3D; +class RenderTargetD3D; + +struct ClearParameters +{ + ClearParameters(); + ClearParameters(const ClearParameters &other); + + gl::DrawBufferMask clearColor; + gl::ColorF colorF; + gl::ColorI colorI; + gl::ColorUI colorUI; + GLenum colorType; + gl::BlendStateExt::ColorMaskStorage::Type colorMask; + + bool clearDepth; + float depthValue; + + bool clearStencil; + GLint stencilValue; + GLuint stencilWriteMask; + + bool scissorEnabled; + gl::Rectangle scissor; +}; + +class FramebufferD3D : public FramebufferImpl +{ + public: + FramebufferD3D(const gl::FramebufferState &data, RendererD3D *renderer); + ~FramebufferD3D() override; + + angle::Result clear(const gl::Context *context, GLbitfield mask) override; + angle::Result clearBufferfv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLfloat *values) override; + angle::Result clearBufferuiv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLuint *values) override; + angle::Result clearBufferiv(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + const GLint *values) override; + angle::Result clearBufferfi(const gl::Context *context, + GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil) override; + + angle::Result readPixels(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + void *pixels) override; + + angle::Result blit(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + GLbitfield mask, + GLenum filter) override; + + gl::FramebufferStatus checkStatus(const gl::Context *context) const override; + + angle::Result syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) override; + + const gl::AttachmentList &getColorAttachmentsForRender(const gl::Context *context); + + const gl::DrawBufferMask getLastColorAttachmentsForRenderMask() const + { + return mColorAttachmentsForRenderMask; + } + + void destroy(const gl::Context *context) override; + + private: + virtual angle::Result clearImpl(const gl::Context *context, + const ClearParameters &clearParams) = 0; + + virtual angle::Result readPixelsImpl(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + size_t outputPitch, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + uint8_t *pixels) = 0; + + virtual angle::Result blitImpl(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + const gl::Rectangle *scissor, + bool blitRenderTarget, + bool blitDepth, + bool blitStencil, + GLenum filter, + const gl::Framebuffer *sourceFramebuffer) = 0; + + RendererD3D *mRenderer; + Optional<gl::AttachmentList> mColorAttachmentsForRender; + gl::DrawBufferMask mCurrentActiveProgramOutputs; + gl::DrawBufferMask mColorAttachmentsForRenderMask; + + gl::FramebufferAttachment mMockAttachment; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_FRAMBUFFERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.cpp new file mode 100644 index 0000000000..e7260e403a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.cpp @@ -0,0 +1,387 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +#include "libANGLE/renderer/d3d/HLSLCompiler.h" + +#include <sstream> + +#include "common/system_utils.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Program.h" +#include "libANGLE/features.h" +#include "libANGLE/histogram_macros.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/trace.h" + +namespace +{ +#if ANGLE_APPEND_ASSEMBLY_TO_SHADER_DEBUG_INFO == ANGLE_ENABLED +# ifdef CREATE_COMPILER_FLAG_INFO +# undef CREATE_COMPILER_FLAG_INFO +# endif + +# define CREATE_COMPILER_FLAG_INFO(flag) \ + { \ + flag, #flag \ + } + +struct CompilerFlagInfo +{ + UINT mFlag; + const char *mName; +}; + +CompilerFlagInfo CompilerFlagInfos[] = { + // NOTE: The data below is copied from d3dcompiler.h + // If something changes there it should be changed here as well + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_DEBUG), // (1 << 0) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_SKIP_VALIDATION), // (1 << 1) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_SKIP_OPTIMIZATION), // (1 << 2) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_PACK_MATRIX_ROW_MAJOR), // (1 << 3) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR), // (1 << 4) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_PARTIAL_PRECISION), // (1 << 5) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT), // (1 << 6) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT), // (1 << 7) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_NO_PRESHADER), // (1 << 8) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_AVOID_FLOW_CONTROL), // (1 << 9) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_PREFER_FLOW_CONTROL), // (1 << 10) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_ENABLE_STRICTNESS), // (1 << 11) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY), // (1 << 12) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_IEEE_STRICTNESS), // (1 << 13) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_OPTIMIZATION_LEVEL0), // (1 << 14) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_OPTIMIZATION_LEVEL1), // 0 + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_OPTIMIZATION_LEVEL2), // ((1 << 14) | (1 << 15)) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_OPTIMIZATION_LEVEL3), // (1 << 15) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_RESERVED16), // (1 << 16) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_RESERVED17), // (1 << 17) + CREATE_COMPILER_FLAG_INFO(D3DCOMPILE_WARNINGS_ARE_ERRORS) // (1 << 18) +}; + +# undef CREATE_COMPILER_FLAG_INFO + +bool IsCompilerFlagSet(UINT mask, UINT flag) +{ + bool isFlagSet = IsMaskFlagSet(mask, flag); + + switch (flag) + { + case D3DCOMPILE_OPTIMIZATION_LEVEL0: + return isFlagSet && !IsMaskFlagSet(mask, UINT(D3DCOMPILE_OPTIMIZATION_LEVEL3)); + + case D3DCOMPILE_OPTIMIZATION_LEVEL1: + return (mask & D3DCOMPILE_OPTIMIZATION_LEVEL2) == UINT(0); + + case D3DCOMPILE_OPTIMIZATION_LEVEL3: + return isFlagSet && !IsMaskFlagSet(mask, UINT(D3DCOMPILE_OPTIMIZATION_LEVEL0)); + + default: + return isFlagSet; + } +} +#endif // ANGLE_APPEND_ASSEMBLY_TO_SHADER_DEBUG_INFO == ANGLE_ENABLED + +constexpr char kOldCompilerLibrary[] = "d3dcompiler_old.dll"; + +enum D3DCompilerLoadLibraryResult +{ + D3DCompilerDefaultLibrarySuccess, + D3DCompilerOldLibrarySuccess, + D3DCompilerFailure, + D3DCompilerEnumBoundary, +}; +} // anonymous namespace + +namespace rx +{ + +CompileConfig::CompileConfig() : flags(0), name() {} + +CompileConfig::CompileConfig(UINT flags, const std::string &name) : flags(flags), name(name) {} + +HLSLCompiler::HLSLCompiler() + : mInitialized(false), + mD3DCompilerModule(nullptr), + mD3DCompileFunc(nullptr), + mD3DDisassembleFunc(nullptr) +{} + +HLSLCompiler::~HLSLCompiler() +{ + release(); +} + +angle::Result HLSLCompiler::ensureInitialized(d3d::Context *context) +{ + if (mInitialized) + { + return angle::Result::Continue; + } + + ANGLE_TRACE_EVENT0("gpu.angle", "HLSLCompiler::initialize"); +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) +# if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES) + // Find a D3DCompiler module that had already been loaded based on a predefined list of + // versions. + static const char *d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES; + + for (size_t i = 0; i < ArraySize(d3dCompilerNames); ++i) + { + if (GetModuleHandleExA(0, d3dCompilerNames[i], &mD3DCompilerModule)) + { + break; + } + } +# endif // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES + + if (!mD3DCompilerModule) + { + // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was + // built with. + mD3DCompilerModule = LoadLibraryA(D3DCOMPILER_DLL_A); + + if (mD3DCompilerModule) + { + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3DCompilerLoadLibraryResult", + D3DCompilerDefaultLibrarySuccess, D3DCompilerEnumBoundary); + } + else + { + WARN() << "Failed to load HLSL compiler library. Using 'old' DLL."; + mD3DCompilerModule = LoadLibraryA(kOldCompilerLibrary); + if (mD3DCompilerModule) + { + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3DCompilerLoadLibraryResult", + D3DCompilerOldLibrarySuccess, D3DCompilerEnumBoundary); + } + } + } + + if (!mD3DCompilerModule) + { + DWORD lastError = GetLastError(); + ERR() << "D3D Compiler LoadLibrary failed. GetLastError=" << lastError; + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3DCompilerLoadLibraryResult", D3DCompilerFailure, + D3DCompilerEnumBoundary); + ANGLE_TRY_HR(context, E_OUTOFMEMORY, "LoadLibrary failed to load D3D Compiler DLL."); + } + + mD3DCompileFunc = + reinterpret_cast<pD3DCompile>(GetProcAddress(mD3DCompilerModule, "D3DCompile")); + ASSERT(mD3DCompileFunc); + + mD3DDisassembleFunc = + reinterpret_cast<pD3DDisassemble>(GetProcAddress(mD3DCompilerModule, "D3DDisassemble")); + ASSERT(mD3DDisassembleFunc); + +#else + // D3D Shader compiler is linked already into this module, so the export + // can be directly assigned. + mD3DCompilerModule = nullptr; + mD3DCompileFunc = reinterpret_cast<pD3DCompile>(D3DCompile); + mD3DDisassembleFunc = reinterpret_cast<pD3DDisassemble>(D3DDisassemble); +#endif + + ANGLE_CHECK_HR(context, mD3DCompileFunc, "Error finding D3DCompile entry point.", + E_OUTOFMEMORY); + + mInitialized = true; + return angle::Result::Continue; +} + +void HLSLCompiler::release() +{ + if (mInitialized) + { + FreeLibrary(mD3DCompilerModule); + mD3DCompilerModule = nullptr; + mD3DCompileFunc = nullptr; + mD3DDisassembleFunc = nullptr; + mInitialized = false; + } +} + +angle::Result HLSLCompiler::compileToBinary(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &hlsl, + const std::string &profile, + const std::vector<CompileConfig> &configs, + const D3D_SHADER_MACRO *overrideMacros, + ID3DBlob **outCompiledBlob, + std::string *outDebugInfo) +{ + ASSERT(mInitialized); + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + ASSERT(mD3DCompilerModule); +#endif + ASSERT(mD3DCompileFunc); + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) && defined(ANGLE_ENABLE_DEBUG_TRACE) + std::string sourcePath = angle::CreateTemporaryFile().value(); + std::ostringstream stream; + stream << "#line 2 \"" << sourcePath << "\"\n\n" << hlsl; + std::string sourceText = stream.str(); + writeFile(sourcePath.c_str(), sourceText.c_str(), sourceText.size()); +#endif + + const D3D_SHADER_MACRO *macros = overrideMacros ? overrideMacros : nullptr; + + for (size_t i = 0; i < configs.size(); ++i) + { + ID3DBlob *errorMessage = nullptr; + ID3DBlob *binary = nullptr; + HRESULT result = S_OK; + + { + ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile", "source", hlsl); + result = mD3DCompileFunc(hlsl.c_str(), hlsl.length(), gl::g_fakepath, macros, nullptr, + "main", profile.c_str(), configs[i].flags, 0, &binary, + &errorMessage); + } + + if (errorMessage) + { + std::string message = static_cast<const char *>(errorMessage->GetBufferPointer()); + SafeRelease(errorMessage); + ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile::Error", "error", errorMessage); + + infoLog.appendSanitized(message.c_str()); + + // This produces unbelievable amounts of spam in about:gpu. + // WARN() << std::endl << hlsl; + + WARN() << std::endl << message; + + if (macros != nullptr) + { + constexpr const char *kLoopRelatedErrors[] = { + // "can't unroll loops marked with loop attribute" + "error X3531:", + + // "cannot have gradient operations inside loops with divergent flow control", + // even though it is counter-intuitive to disable unrolling for this error, some + // very long shaders have trouble deciding which loops to unroll and turning off + // forced unrolls allows them to compile properly. + "error X4014:", + + // "array index out of bounds", loop unrolling can result in invalid array + // access if the indices become constant, causing loops that may never be + // executed to generate compilation errors + "error X3504:", + }; + + bool hasLoopRelatedError = false; + for (const char *errorType : kLoopRelatedErrors) + { + if (message.find(errorType) != std::string::npos) + { + hasLoopRelatedError = true; + break; + } + } + + if (hasLoopRelatedError) + { + // Disable [loop] and [flatten] + macros = nullptr; + + // Retry without changing compiler flags + i--; + continue; + } + } + } + + if (SUCCEEDED(result)) + { + *outCompiledBlob = binary; + + (*outDebugInfo) += + "// COMPILER INPUT HLSL BEGIN\n\n" + hlsl + "\n// COMPILER INPUT HLSL END\n"; + +#if ANGLE_APPEND_ASSEMBLY_TO_SHADER_DEBUG_INFO == ANGLE_ENABLED + (*outDebugInfo) += "\n\n// ASSEMBLY BEGIN\n\n"; + (*outDebugInfo) += "// Compiler configuration: " + configs[i].name + "\n// Flags:\n"; + for (size_t fIx = 0; fIx < ArraySize(CompilerFlagInfos); ++fIx) + { + if (IsCompilerFlagSet(configs[i].flags, CompilerFlagInfos[fIx].mFlag)) + { + (*outDebugInfo) += std::string("// ") + CompilerFlagInfos[fIx].mName + "\n"; + } + } + + (*outDebugInfo) += "// Macros:\n"; + if (macros == nullptr) + { + (*outDebugInfo) += "// - : -\n"; + } + else + { + for (const D3D_SHADER_MACRO *mIt = macros; mIt->Name != nullptr; ++mIt) + { + (*outDebugInfo) += + std::string("// ") + mIt->Name + " : " + mIt->Definition + "\n"; + } + } + + std::string disassembly; + ANGLE_TRY(disassembleBinary(context, binary, &disassembly)); + (*outDebugInfo) += "\n" + disassembly + "\n// ASSEMBLY END\n"; +#endif // ANGLE_APPEND_ASSEMBLY_TO_SHADER_DEBUG_INFO == ANGLE_ENABLED + return angle::Result::Continue; + } + + if (result == E_OUTOFMEMORY) + { + *outCompiledBlob = nullptr; + ANGLE_TRY_HR(context, result, "HLSL compiler had an unexpected failure"); + } + + infoLog << "Warning: D3D shader compilation failed with " << configs[i].name << " flags. (" + << profile << ")"; + + if (i + 1 < configs.size()) + { + infoLog << " Retrying with " << configs[i + 1].name; + } + } + + // None of the configurations succeeded in compiling this shader but the compiler is still + // intact + *outCompiledBlob = nullptr; + return angle::Result::Continue; +} + +angle::Result HLSLCompiler::disassembleBinary(d3d::Context *context, + ID3DBlob *shaderBinary, + std::string *disassemblyOut) +{ + ANGLE_TRY(ensureInitialized(context)); + + // Retrieve disassembly + UINT flags = D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS | D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING; + ID3DBlob *disassembly = nullptr; + pD3DDisassemble disassembleFunc = reinterpret_cast<pD3DDisassemble>(mD3DDisassembleFunc); + LPCVOID buffer = shaderBinary->GetBufferPointer(); + SIZE_T bufSize = shaderBinary->GetBufferSize(); + HRESULT result = disassembleFunc(buffer, bufSize, flags, "", &disassembly); + + if (SUCCEEDED(result)) + { + *disassemblyOut = std::string(static_cast<const char *>(disassembly->GetBufferPointer())); + } + else + { + *disassemblyOut = ""; + } + + SafeRelease(disassembly); + + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.h new file mode 100644 index 0000000000..98a17799cf --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/HLSLCompiler.h @@ -0,0 +1,74 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// HLSLCompiler: Wrapper for the D3DCompiler DLL. +// + +#ifndef LIBANGLE_RENDERER_D3D_HLSLCOMPILER_H_ +#define LIBANGLE_RENDERER_D3D_HLSLCOMPILER_H_ + +#include "libANGLE/Error.h" + +#include "common/angleutils.h" +#include "common/platform.h" + +#include <string> +#include <vector> + +namespace gl +{ +class InfoLog; +} // namespace gl + +namespace rx +{ +namespace d3d +{ +class Context; +} // namespace d3d + +struct CompileConfig +{ + UINT flags; + std::string name; + + CompileConfig(); + CompileConfig(UINT flags, const std::string &name); +}; + +class HLSLCompiler : angle::NonCopyable +{ + public: + HLSLCompiler(); + ~HLSLCompiler(); + + void release(); + + // Attempt to compile a HLSL shader using the supplied configurations, may output a NULL + // compiled blob even if no GL errors are returned. + angle::Result compileToBinary(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &hlsl, + const std::string &profile, + const std::vector<CompileConfig> &configs, + const D3D_SHADER_MACRO *overrideMacros, + ID3DBlob **outCompiledBlob, + std::string *outDebugInfo); + + angle::Result disassembleBinary(d3d::Context *context, + ID3DBlob *shaderBinary, + std::string *disassemblyOut); + angle::Result ensureInitialized(d3d::Context *context); + + private: + bool mInitialized; + HMODULE mD3DCompilerModule; + pD3DCompile mD3DCompileFunc; + pD3DDisassemble mD3DDisassembleFunc; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_HLSLCOMPILER_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.cpp new file mode 100644 index 0000000000..67ad3aee70 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.cpp @@ -0,0 +1,56 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Image.h: Implements the rx::Image class, an abstract base class for the +// renderer-specific classes which will define the interface to the underlying +// surfaces or resources. + +#include "libANGLE/renderer/d3d/ImageD3D.h" + +namespace rx +{ + +ImageD3D::ImageD3D() + : mWidth(0), + mHeight(0), + mDepth(0), + mInternalFormat(GL_NONE), + mRenderable(false), + mType(gl::TextureType::InvalidEnum), + mDirty(false) +{} + +angle::Result ImageD3D::setManagedSurface2D(const gl::Context *context, + TextureStorage *storage, + int level) +{ + return angle::Result::Continue; +} + +angle::Result ImageD3D::setManagedSurfaceCube(const gl::Context *context, + TextureStorage *storage, + int face, + int level) +{ + return angle::Result::Continue; +} + +angle::Result ImageD3D::setManagedSurface3D(const gl::Context *context, + TextureStorage *storage, + int level) +{ + return angle::Result::Continue; +} + +angle::Result ImageD3D::setManagedSurface2DArray(const gl::Context *context, + TextureStorage *storage, + int layer, + int level) +{ + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.h new file mode 100644 index 0000000000..ac58ca5cf6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ImageD3D.h @@ -0,0 +1,105 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ImageD3D.h: Defines the rx::ImageD3D class, an abstract base class for the +// renderer-specific classes which will define the interface to the underlying +// surfaces or resources. + +#ifndef LIBANGLE_RENDERER_D3D_IMAGED3D_H_ +#define LIBANGLE_RENDERER_D3D_IMAGED3D_H_ + +#include "common/debug.h" + +#include "common/PackedEnums.h" +#include "libANGLE/Error.h" +#include "libANGLE/angletypes.h" + +namespace gl +{ +class Context; +class Framebuffer; +class ImageIndex; +struct PixelUnpackState; +} // namespace gl + +namespace rx +{ +class TextureStorage; +class RendererD3D; +class RenderTargetD3D; + +class ImageD3D : angle::NonCopyable +{ + public: + ImageD3D(); + virtual ~ImageD3D() {} + + GLsizei getWidth() const { return mWidth; } + GLsizei getHeight() const { return mHeight; } + GLsizei getDepth() const { return mDepth; } + GLenum getInternalFormat() const { return mInternalFormat; } + gl::TextureType getType() const { return mType; } + bool isRenderableFormat() const { return mRenderable; } + + void markDirty() { mDirty = true; } + void markClean() { mDirty = false; } + virtual bool isDirty() const = 0; + + virtual bool redefine(gl::TextureType type, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) = 0; + + virtual angle::Result loadData(const gl::Context *context, + const gl::Box &area, + const gl::PixelUnpackState &unpack, + GLenum type, + const void *input, + bool applySkipImages) = 0; + virtual angle::Result loadCompressedData(const gl::Context *context, + const gl::Box &area, + const void *input) = 0; + + virtual angle::Result setManagedSurface2D(const gl::Context *context, + TextureStorage *storage, + int level); + virtual angle::Result setManagedSurfaceCube(const gl::Context *context, + TextureStorage *storage, + int face, + int level); + virtual angle::Result setManagedSurface3D(const gl::Context *context, + TextureStorage *storage, + int level); + virtual angle::Result setManagedSurface2DArray(const gl::Context *context, + TextureStorage *storage, + int layer, + int level); + virtual angle::Result copyToStorage(const gl::Context *context, + TextureStorage *storage, + const gl::ImageIndex &index, + const gl::Box ®ion) = 0; + + virtual angle::Result copyFromTexStorage(const gl::Context *context, + const gl::ImageIndex &imageIndex, + TextureStorage *source) = 0; + virtual angle::Result copyFromFramebuffer(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + const gl::Framebuffer *source) = 0; + + protected: + GLsizei mWidth; + GLsizei mHeight; + GLsizei mDepth; + GLenum mInternalFormat; + bool mRenderable; + gl::TextureType mType; + + bool mDirty; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_IMAGED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.cpp new file mode 100644 index 0000000000..423067e67e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.cpp @@ -0,0 +1,183 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexBuffer.cpp: Defines the abstract IndexBuffer class and IndexBufferInterface +// class with derivations, classes that perform graphics API agnostic index buffer operations. + +#include "libANGLE/renderer/d3d/IndexBuffer.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" + +namespace rx +{ + +unsigned int IndexBuffer::mNextSerial = 1; + +IndexBuffer::IndexBuffer() +{ + updateSerial(); +} + +IndexBuffer::~IndexBuffer() {} + +unsigned int IndexBuffer::getSerial() const +{ + return mSerial; +} + +void IndexBuffer::updateSerial() +{ + mSerial = mNextSerial++; +} + +IndexBufferInterface::IndexBufferInterface(BufferFactoryD3D *factory, bool dynamic) +{ + mIndexBuffer = factory->createIndexBuffer(); + + mDynamic = dynamic; + mWritePosition = 0; +} + +IndexBufferInterface::~IndexBufferInterface() +{ + if (mIndexBuffer) + { + delete mIndexBuffer; + } +} + +gl::DrawElementsType IndexBufferInterface::getIndexType() const +{ + return mIndexBuffer->getIndexType(); +} + +unsigned int IndexBufferInterface::getBufferSize() const +{ + return mIndexBuffer->getBufferSize(); +} + +unsigned int IndexBufferInterface::getSerial() const +{ + return mIndexBuffer->getSerial(); +} + +angle::Result IndexBufferInterface::mapBuffer(const gl::Context *context, + unsigned int size, + void **outMappedMemory, + unsigned int *streamOffset) +{ + // Protect against integer overflow + bool check = (mWritePosition + size < mWritePosition); + ANGLE_CHECK(GetImplAs<ContextD3D>(context), !check, + "Mapping of internal index buffer would cause an integer overflow.", + GL_OUT_OF_MEMORY); + + angle::Result error = mIndexBuffer->mapBuffer(context, mWritePosition, size, outMappedMemory); + if (error == angle::Result::Stop) + { + if (outMappedMemory) + { + *outMappedMemory = nullptr; + } + return error; + } + + if (streamOffset) + { + *streamOffset = mWritePosition; + } + + mWritePosition += size; + return angle::Result::Continue; +} + +angle::Result IndexBufferInterface::unmapBuffer(const gl::Context *context) +{ + return mIndexBuffer->unmapBuffer(context); +} + +IndexBuffer *IndexBufferInterface::getIndexBuffer() const +{ + return mIndexBuffer; +} + +unsigned int IndexBufferInterface::getWritePosition() const +{ + return mWritePosition; +} + +void IndexBufferInterface::setWritePosition(unsigned int writePosition) +{ + mWritePosition = writePosition; +} + +angle::Result IndexBufferInterface::discard(const gl::Context *context) +{ + return mIndexBuffer->discard(context); +} + +angle::Result IndexBufferInterface::setBufferSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) +{ + if (mIndexBuffer->getBufferSize() == 0) + { + return mIndexBuffer->initialize(context, bufferSize, indexType, mDynamic); + } + else + { + return mIndexBuffer->setSize(context, bufferSize, indexType); + } +} + +StreamingIndexBufferInterface::StreamingIndexBufferInterface(BufferFactoryD3D *factory) + : IndexBufferInterface(factory, true) +{} + +StreamingIndexBufferInterface::~StreamingIndexBufferInterface() {} + +angle::Result StreamingIndexBufferInterface::reserveBufferSpace(const gl::Context *context, + unsigned int size, + gl::DrawElementsType indexType) +{ + unsigned int curBufferSize = getBufferSize(); + unsigned int writePos = getWritePosition(); + if (size > curBufferSize) + { + ANGLE_TRY(setBufferSize(context, std::max(size, 2 * curBufferSize), indexType)); + setWritePosition(0); + } + else if (writePos + size > curBufferSize || writePos + size < writePos) + { + ANGLE_TRY(discard(context)); + setWritePosition(0); + } + + return angle::Result::Continue; +} + +StaticIndexBufferInterface::StaticIndexBufferInterface(BufferFactoryD3D *factory) + : IndexBufferInterface(factory, false) +{} + +StaticIndexBufferInterface::~StaticIndexBufferInterface() {} + +angle::Result StaticIndexBufferInterface::reserveBufferSpace(const gl::Context *context, + unsigned int size, + gl::DrawElementsType indexType) +{ + unsigned int curSize = getBufferSize(); + if (curSize == 0) + { + return setBufferSize(context, size, indexType); + } + + ASSERT(curSize >= size && indexType == getIndexType()); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.h new file mode 100644 index 0000000000..7bab52a9f0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexBuffer.h @@ -0,0 +1,125 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexBuffer.h: Defines the abstract IndexBuffer class and IndexBufferInterface +// class with derivations, classes that perform graphics API agnostic index buffer operations. + +#ifndef LIBANGLE_RENDERER_D3D_INDEXBUFFER_H_ +#define LIBANGLE_RENDERER_D3D_INDEXBUFFER_H_ + +#include "common/PackedEnums.h" +#include "common/angleutils.h" +#include "libANGLE/Error.h" + +namespace gl +{ +class Context; +} // namespace gl + +namespace rx +{ +class BufferFactoryD3D; + +class IndexBuffer : angle::NonCopyable +{ + public: + IndexBuffer(); + virtual ~IndexBuffer(); + + virtual angle::Result initialize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType, + bool dynamic) = 0; + + virtual angle::Result mapBuffer(const gl::Context *context, + unsigned int offset, + unsigned int size, + void **outMappedMemory) = 0; + virtual angle::Result unmapBuffer(const gl::Context *context) = 0; + + virtual angle::Result discard(const gl::Context *context) = 0; + + virtual gl::DrawElementsType getIndexType() const = 0; + virtual unsigned int getBufferSize() const = 0; + virtual angle::Result setSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) = 0; + + unsigned int getSerial() const; + + protected: + void updateSerial(); + + private: + unsigned int mSerial; + static unsigned int mNextSerial; +}; + +class IndexBufferInterface : angle::NonCopyable +{ + public: + IndexBufferInterface(BufferFactoryD3D *factory, bool dynamic); + virtual ~IndexBufferInterface(); + + virtual angle::Result reserveBufferSpace(const gl::Context *context, + unsigned int size, + gl::DrawElementsType indexType) = 0; + + gl::DrawElementsType getIndexType() const; + unsigned int getBufferSize() const; + + unsigned int getSerial() const; + + angle::Result mapBuffer(const gl::Context *context, + unsigned int size, + void **outMappedMemory, + unsigned int *streamOffset); + angle::Result unmapBuffer(const gl::Context *context); + + IndexBuffer *getIndexBuffer() const; + + protected: + unsigned int getWritePosition() const; + void setWritePosition(unsigned int writePosition); + + angle::Result discard(const gl::Context *context); + + angle::Result setBufferSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType); + + private: + IndexBuffer *mIndexBuffer; + + unsigned int mWritePosition; + bool mDynamic; +}; + +class StreamingIndexBufferInterface : public IndexBufferInterface +{ + public: + explicit StreamingIndexBufferInterface(BufferFactoryD3D *factory); + ~StreamingIndexBufferInterface() override; + + angle::Result reserveBufferSpace(const gl::Context *context, + unsigned int size, + gl::DrawElementsType indexType) override; +}; + +class StaticIndexBufferInterface : public IndexBufferInterface +{ + public: + explicit StaticIndexBufferInterface(BufferFactoryD3D *factory); + ~StaticIndexBufferInterface() override; + + angle::Result reserveBufferSpace(const gl::Context *context, + unsigned int size, + gl::DrawElementsType indexType) override; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_INDEXBUFFER_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.cpp new file mode 100644 index 0000000000..dd8f45342f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.cpp @@ -0,0 +1,318 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexDataManager.cpp: Defines the IndexDataManager, a class that +// runs the Buffer translation process for index buffers. + +#include "libANGLE/renderer/d3d/IndexDataManager.h" + +#include "common/utilities.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/IndexBuffer.h" + +namespace rx +{ + +namespace +{ + +template <typename InputT, typename DestT> +void ConvertIndexArray(const void *input, + gl::DrawElementsType sourceType, + void *output, + gl::DrawElementsType destinationType, + GLsizei count, + bool usePrimitiveRestartFixedIndex) +{ + const InputT *in = static_cast<const InputT *>(input); + DestT *out = static_cast<DestT *>(output); + + if (usePrimitiveRestartFixedIndex) + { + InputT srcRestartIndex = static_cast<InputT>(gl::GetPrimitiveRestartIndex(sourceType)); + DestT destRestartIndex = static_cast<DestT>(gl::GetPrimitiveRestartIndex(destinationType)); + for (GLsizei i = 0; i < count; i++) + { + out[i] = (in[i] == srcRestartIndex ? destRestartIndex : static_cast<DestT>(in[i])); + } + } + else + { + for (GLsizei i = 0; i < count; i++) + { + out[i] = static_cast<DestT>(in[i]); + } + } +} + +void ConvertIndices(gl::DrawElementsType sourceType, + gl::DrawElementsType destinationType, + const void *input, + GLsizei count, + void *output, + bool usePrimitiveRestartFixedIndex) +{ + if (sourceType == destinationType) + { + const GLuint dstTypeSize = gl::GetDrawElementsTypeSize(destinationType); + memcpy(output, input, count * dstTypeSize); + return; + } + + if (sourceType == gl::DrawElementsType::UnsignedByte) + { + ASSERT(destinationType == gl::DrawElementsType::UnsignedShort); + ConvertIndexArray<GLubyte, GLushort>(input, sourceType, output, destinationType, count, + usePrimitiveRestartFixedIndex); + } + else if (sourceType == gl::DrawElementsType::UnsignedShort) + { + ASSERT(destinationType == gl::DrawElementsType::UnsignedInt); + ConvertIndexArray<GLushort, GLuint>(input, sourceType, output, destinationType, count, + usePrimitiveRestartFixedIndex); + } + else + UNREACHABLE(); +} + +angle::Result StreamInIndexBuffer(const gl::Context *context, + IndexBufferInterface *buffer, + const void *data, + unsigned int count, + gl::DrawElementsType srcType, + gl::DrawElementsType dstType, + bool usePrimitiveRestartFixedIndex, + unsigned int *offset) +{ + const GLuint dstTypeBytesShift = gl::GetDrawElementsTypeShift(dstType); + + bool check = (count > (std::numeric_limits<unsigned int>::max() >> dstTypeBytesShift)); + ANGLE_CHECK(GetImplAs<ContextD3D>(context), !check, + "Reserving indices exceeds the maximum buffer size.", GL_OUT_OF_MEMORY); + + unsigned int bufferSizeRequired = count << dstTypeBytesShift; + ANGLE_TRY(buffer->reserveBufferSpace(context, bufferSizeRequired, dstType)); + + void *output = nullptr; + ANGLE_TRY(buffer->mapBuffer(context, bufferSizeRequired, &output, offset)); + + ConvertIndices(srcType, dstType, data, count, output, usePrimitiveRestartFixedIndex); + + ANGLE_TRY(buffer->unmapBuffer(context)); + return angle::Result::Continue; +} +} // anonymous namespace + +// IndexDataManager implementation. +IndexDataManager::IndexDataManager(BufferFactoryD3D *factory) + : mFactory(factory), mStreamingBufferShort(), mStreamingBufferInt() +{} + +IndexDataManager::~IndexDataManager() {} + +void IndexDataManager::deinitialize() +{ + mStreamingBufferShort.reset(); + mStreamingBufferInt.reset(); +} + +// This function translates a GL-style indices into DX-style indices, with their description +// returned in translated. +// GL can specify vertex data in immediate mode (pointer to CPU array of indices), which is not +// possible in DX and requires streaming (Case 1). If the GL indices are specified with a buffer +// (Case 2), in a format supported by DX (subcase a) then all is good. +// When we have a buffer with an unsupported format (subcase b) then we need to do some translation: +// we will start by falling back to streaming, and after a while will start using a static +// translated copy of the index buffer. +angle::Result IndexDataManager::prepareIndexData(const gl::Context *context, + gl::DrawElementsType srcType, + gl::DrawElementsType dstType, + GLsizei count, + gl::Buffer *glBuffer, + const void *indices, + TranslatedIndexData *translated) +{ + GLuint srcTypeBytes = gl::GetDrawElementsTypeSize(srcType); + GLuint srcTypeShift = gl::GetDrawElementsTypeShift(srcType); + GLuint dstTypeShift = gl::GetDrawElementsTypeShift(dstType); + + BufferD3D *buffer = glBuffer ? GetImplAs<BufferD3D>(glBuffer) : nullptr; + + translated->indexType = dstType; + translated->srcIndexData.srcBuffer = buffer; + translated->srcIndexData.srcIndices = indices; + translated->srcIndexData.srcIndexType = srcType; + translated->srcIndexData.srcCount = count; + + // Context can be nullptr in perf tests. + bool primitiveRestartFixedIndexEnabled = + context ? context->getState().isPrimitiveRestartEnabled() : false; + + // Case 1: the indices are passed by pointer, which forces the streaming of index data + if (glBuffer == nullptr) + { + translated->storage = nullptr; + return streamIndexData(context, indices, count, srcType, dstType, + primitiveRestartFixedIndexEnabled, translated); + } + + // Case 2: the indices are already in a buffer + unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices)); + ASSERT(srcTypeBytes * static_cast<unsigned int>(count) + offset <= buffer->getSize()); + + bool offsetAligned = IsOffsetAligned(srcType, offset); + + // Case 2a: the buffer can be used directly + if (offsetAligned && buffer->supportsDirectBinding() && dstType == srcType) + { + translated->storage = buffer; + translated->indexBuffer = nullptr; + translated->serial = buffer->getSerial(); + translated->startIndex = (offset >> srcTypeShift); + translated->startOffset = offset; + return angle::Result::Continue; + } + + translated->storage = nullptr; + + // Case 2b: use a static translated copy or fall back to streaming + StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer(); + + bool staticBufferInitialized = staticBuffer && staticBuffer->getBufferSize() != 0; + bool staticBufferUsable = + staticBuffer && offsetAligned && staticBuffer->getIndexType() == dstType; + + if (staticBufferInitialized && !staticBufferUsable) + { + buffer->invalidateStaticData(context); + staticBuffer = nullptr; + } + + if (staticBuffer == nullptr || !offsetAligned) + { + const uint8_t *bufferData = nullptr; + ANGLE_TRY(buffer->getData(context, &bufferData)); + ASSERT(bufferData != nullptr); + + ANGLE_TRY(streamIndexData(context, bufferData + offset, count, srcType, dstType, + primitiveRestartFixedIndexEnabled, translated)); + buffer->promoteStaticUsage(context, count << srcTypeShift); + } + else + { + if (!staticBufferInitialized) + { + const uint8_t *bufferData = nullptr; + ANGLE_TRY(buffer->getData(context, &bufferData)); + ASSERT(bufferData != nullptr); + + unsigned int convertCount = + static_cast<unsigned int>(buffer->getSize()) >> srcTypeShift; + ANGLE_TRY(StreamInIndexBuffer(context, staticBuffer, bufferData, convertCount, srcType, + dstType, primitiveRestartFixedIndexEnabled, nullptr)); + } + ASSERT(offsetAligned && staticBuffer->getIndexType() == dstType); + + translated->indexBuffer = staticBuffer->getIndexBuffer(); + translated->serial = staticBuffer->getSerial(); + translated->startIndex = (offset >> srcTypeShift); + translated->startOffset = (offset >> srcTypeShift) << dstTypeShift; + } + + return angle::Result::Continue; +} + +angle::Result IndexDataManager::streamIndexData(const gl::Context *context, + const void *data, + unsigned int count, + gl::DrawElementsType srcType, + gl::DrawElementsType dstType, + bool usePrimitiveRestartFixedIndex, + TranslatedIndexData *translated) +{ + const GLuint dstTypeShift = gl::GetDrawElementsTypeShift(dstType); + + IndexBufferInterface *indexBuffer = nullptr; + ANGLE_TRY(getStreamingIndexBuffer(context, dstType, &indexBuffer)); + ASSERT(indexBuffer != nullptr); + + unsigned int offset; + ANGLE_TRY(StreamInIndexBuffer(context, indexBuffer, data, count, srcType, dstType, + usePrimitiveRestartFixedIndex, &offset)); + + translated->indexBuffer = indexBuffer->getIndexBuffer(); + translated->serial = indexBuffer->getSerial(); + translated->startIndex = (offset >> dstTypeShift); + translated->startOffset = offset; + + return angle::Result::Continue; +} + +angle::Result IndexDataManager::getStreamingIndexBuffer(const gl::Context *context, + gl::DrawElementsType destinationIndexType, + IndexBufferInterface **outBuffer) +{ + ASSERT(outBuffer); + ASSERT(destinationIndexType == gl::DrawElementsType::UnsignedShort || + destinationIndexType == gl::DrawElementsType::UnsignedInt); + + auto &streamingBuffer = (destinationIndexType == gl::DrawElementsType::UnsignedInt) + ? mStreamingBufferInt + : mStreamingBufferShort; + + if (!streamingBuffer) + { + StreamingBuffer newBuffer(new StreamingIndexBufferInterface(mFactory)); + ANGLE_TRY(newBuffer->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE, + destinationIndexType)); + streamingBuffer = std::move(newBuffer); + } + + *outBuffer = streamingBuffer.get(); + return angle::Result::Continue; +} + +angle::Result GetIndexTranslationDestType(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + bool usePrimitiveRestartWorkaround, + gl::DrawElementsType *destTypeOut) +{ + // Avoid D3D11's primitive restart index value + // see http://msdn.microsoft.com/en-us/library/windows/desktop/bb205124(v=vs.85).aspx + if (usePrimitiveRestartWorkaround) + { + // Conservatively assume we need to translate the indices for draw indirect. + // This is a bit of a trick. We assume the count for an indirect draw is zero. + if (indexCount == 0) + { + *destTypeOut = gl::DrawElementsType::UnsignedInt; + return angle::Result::Continue; + } + + gl::IndexRange indexRange; + ANGLE_TRY(context->getState().getVertexArray()->getIndexRange( + context, indexType, indexCount, indices, &indexRange)); + if (indexRange.end == gl::GetPrimitiveRestartIndex(indexType)) + { + *destTypeOut = gl::DrawElementsType::UnsignedInt; + return angle::Result::Continue; + } + } + + *destTypeOut = (indexType == gl::DrawElementsType::UnsignedInt) + ? gl::DrawElementsType::UnsignedInt + : gl::DrawElementsType::UnsignedShort; + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.h new file mode 100644 index 0000000000..53bfc721da --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/IndexDataManager.h @@ -0,0 +1,112 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexDataManager.h: Defines the IndexDataManager, a class that +// runs the Buffer translation process for index buffers. + +#ifndef LIBANGLE_INDEXDATAMANAGER_H_ +#define LIBANGLE_INDEXDATAMANAGER_H_ + +#include <GLES2/gl2.h> + +#include "common/angleutils.h" +#include "common/mathutil.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace +{ +enum +{ + INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) +}; +} + +namespace gl +{ +class Buffer; +} + +namespace rx +{ +class IndexBufferInterface; +class StaticIndexBufferInterface; +class StreamingIndexBufferInterface; +class IndexBuffer; +class BufferD3D; +class RendererD3D; + +struct SourceIndexData +{ + BufferD3D *srcBuffer; + const void *srcIndices; + unsigned int srcCount; + gl::DrawElementsType srcIndexType; + bool srcIndicesChanged; +}; + +struct TranslatedIndexData +{ + unsigned int startIndex; + unsigned int startOffset; // In bytes + + IndexBuffer *indexBuffer; + BufferD3D *storage; + gl::DrawElementsType indexType; + unsigned int serial; + + SourceIndexData srcIndexData; +}; + +class IndexDataManager : angle::NonCopyable +{ + public: + explicit IndexDataManager(BufferFactoryD3D *factory); + virtual ~IndexDataManager(); + + void deinitialize(); + + angle::Result prepareIndexData(const gl::Context *context, + gl::DrawElementsType srcType, + gl::DrawElementsType dstType, + GLsizei count, + gl::Buffer *glBuffer, + const void *indices, + TranslatedIndexData *translated); + + private: + angle::Result streamIndexData(const gl::Context *context, + const void *data, + unsigned int count, + gl::DrawElementsType srcType, + gl::DrawElementsType dstType, + bool usePrimitiveRestartFixedIndex, + TranslatedIndexData *translated); + angle::Result getStreamingIndexBuffer(const gl::Context *context, + gl::DrawElementsType destinationIndexType, + IndexBufferInterface **outBuffer); + + using StreamingBuffer = std::unique_ptr<StreamingIndexBufferInterface>; + + BufferFactoryD3D *const mFactory; + std::unique_ptr<StreamingIndexBufferInterface> mStreamingBufferShort; + std::unique_ptr<StreamingIndexBufferInterface> mStreamingBufferInt; +}; + +angle::Result GetIndexTranslationDestType(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + bool usePrimitiveRestartWorkaround, + gl::DrawElementsType *destTypeOut); + +ANGLE_INLINE bool IsOffsetAligned(gl::DrawElementsType elementType, unsigned int offset) +{ + return (offset % gl::GetDrawElementsTypeSize(elementType) == 0); +} +} // namespace rx + +#endif // LIBANGLE_INDEXDATAMANAGER_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.cpp new file mode 100644 index 0000000000..a8543a06d7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.cpp @@ -0,0 +1,19 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindowD3D.cpp: Defines NativeWindowD3D, a class for managing and performing operations on +// an EGLNativeWindowType for the D3D renderers. + +#include "libANGLE/renderer/d3d/NativeWindowD3D.h" + +namespace rx +{ + +NativeWindowD3D::NativeWindowD3D(EGLNativeWindowType window) : mWindow(window) {} + +NativeWindowD3D::~NativeWindowD3D() {} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.h new file mode 100644 index 0000000000..8560f16bde --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/NativeWindowD3D.h @@ -0,0 +1,38 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindowD3D.h: Defines NativeWindowD3D, a class for managing and performing operations on an +// EGLNativeWindowType for the D3D renderers. + +#ifndef LIBANGLE_RENDERER_D3D_NATIVEWINDOWD3D_H_ +#define LIBANGLE_RENDERER_D3D_NATIVEWINDOWD3D_H_ + +#include "common/debug.h" +#include "common/platform.h" + +#include <EGL/eglplatform.h> +#include "libANGLE/Config.h" + +namespace rx +{ +class NativeWindowD3D : angle::NonCopyable +{ + public: + NativeWindowD3D(EGLNativeWindowType window); + virtual ~NativeWindowD3D(); + + virtual bool initialize() = 0; + virtual bool getClientRect(LPRECT rect) const = 0; + virtual bool isIconic() const = 0; + + inline EGLNativeWindowType getNativeWindow() const { return mWindow; } + + private: + EGLNativeWindowType mWindow; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_NATIVEWINDOWD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.cpp new file mode 100644 index 0000000000..b38ede4133 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.cpp @@ -0,0 +1,3412 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ProgramD3D.cpp: Defines the rx::ProgramD3D class which implements rx::ProgramImpl. + +#include "libANGLE/renderer/d3d/ProgramD3D.h" + +#include "common/MemoryBuffer.h" +#include "common/bitset_utils.h" +#include "common/string_utils.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Program.h" +#include "libANGLE/ProgramLinkedResources.h" +#include "libANGLE/Uniform.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/features.h" +#include "libANGLE/queryconversions.h" +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/DynamicHLSL.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/ShaderExecutableD3D.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" +#include "libANGLE/renderer/renderer_utils.h" +#include "libANGLE/trace.h" + +using namespace angle; + +namespace rx +{ + +namespace +{ + +void GetDefaultInputLayoutFromShader(const gl::Context *context, + gl::Shader *vertexShader, + gl::InputLayout *inputLayoutOut) +{ + inputLayoutOut->clear(); + + if (!vertexShader) + { + return; + } + + for (const sh::ShaderVariable &shaderAttr : vertexShader->getActiveAttributes(context)) + { + if (shaderAttr.type != GL_NONE) + { + GLenum transposedType = gl::TransposeMatrixType(shaderAttr.type); + + for (size_t rowIndex = 0; + static_cast<int>(rowIndex) < gl::VariableRowCount(transposedType); ++rowIndex) + { + GLenum componentType = gl::VariableComponentType(transposedType); + GLuint components = static_cast<GLuint>(gl::VariableColumnCount(transposedType)); + bool pureInt = (componentType != GL_FLOAT); + + gl::VertexAttribType attribType = + gl::FromGLenum<gl::VertexAttribType>(componentType); + + angle::FormatID defaultID = + gl::GetVertexFormatID(attribType, GL_FALSE, components, pureInt); + + inputLayoutOut->push_back(defaultID); + } + } + } +} + +size_t GetMaxOutputIndex(const std::vector<PixelShaderOutputVariable> &shaderOutputVars, + size_t location) +{ + size_t maxIndex = 0; + for (auto &outputVar : shaderOutputVars) + { + if (outputVar.outputLocation == location) + { + maxIndex = std::max(maxIndex, outputVar.outputIndex); + } + } + return maxIndex; +} + +void GetDefaultOutputLayoutFromShader( + const std::vector<PixelShaderOutputVariable> &shaderOutputVars, + std::vector<GLenum> *outputLayoutOut) +{ + outputLayoutOut->clear(); + + if (!shaderOutputVars.empty()) + { + size_t location = shaderOutputVars[0].outputLocation; + size_t maxIndex = GetMaxOutputIndex(shaderOutputVars, location); + outputLayoutOut->assign(maxIndex + 1, + GL_COLOR_ATTACHMENT0 + static_cast<unsigned int>(location)); + } +} + +void GetDefaultImage2DBindLayoutFromShader(const std::vector<sh::ShaderVariable> &image2DUniforms, + gl::ImageUnitTextureTypeMap *image2DBindLayout) +{ + image2DBindLayout->clear(); + + for (const sh::ShaderVariable &image2D : image2DUniforms) + { + if (gl::IsImage2DType(image2D.type)) + { + if (image2D.binding == -1) + { + image2DBindLayout->insert(std::make_pair(0, gl::TextureType::_2D)); + } + else + { + for (unsigned int index = 0; index < image2D.getArraySizeProduct(); index++) + { + image2DBindLayout->insert( + std::make_pair(image2D.binding + index, gl::TextureType::_2D)); + } + } + } + } +} + +gl::PrimitiveMode GetGeometryShaderTypeFromDrawMode(gl::PrimitiveMode drawMode) +{ + switch (drawMode) + { + // Uses the point sprite geometry shader. + case gl::PrimitiveMode::Points: + return gl::PrimitiveMode::Points; + + // All line drawing uses the same geometry shader. + case gl::PrimitiveMode::Lines: + case gl::PrimitiveMode::LineStrip: + case gl::PrimitiveMode::LineLoop: + return gl::PrimitiveMode::Lines; + + // The triangle fan primitive is emulated with strips in D3D11. + case gl::PrimitiveMode::Triangles: + case gl::PrimitiveMode::TriangleFan: + return gl::PrimitiveMode::Triangles; + + // Special case for triangle strips. + case gl::PrimitiveMode::TriangleStrip: + return gl::PrimitiveMode::TriangleStrip; + + default: + UNREACHABLE(); + return gl::PrimitiveMode::InvalidEnum; + } +} + +bool HasFlatInterpolationVarying(const std::vector<sh::ShaderVariable> &varyings) +{ + // Note: this assumes nested structs can only be packed with one interpolation. + for (const auto &varying : varyings) + { + if (varying.interpolation == sh::INTERPOLATION_FLAT) + { + return true; + } + } + + return false; +} + +bool FindFlatInterpolationVaryingPerShader(const gl::Context *context, gl::Shader *shader) +{ + ASSERT(shader); + switch (shader->getType()) + { + case gl::ShaderType::Vertex: + return HasFlatInterpolationVarying(shader->getOutputVaryings(context)); + case gl::ShaderType::Fragment: + return HasFlatInterpolationVarying(shader->getInputVaryings(context)); + case gl::ShaderType::Geometry: + return HasFlatInterpolationVarying(shader->getInputVaryings(context)) || + HasFlatInterpolationVarying(shader->getOutputVaryings(context)); + default: + UNREACHABLE(); + return false; + } +} + +bool FindFlatInterpolationVarying(const gl::Context *context, + const gl::ShaderMap<gl::Shader *> &shaders) +{ + for (gl::ShaderType shaderType : gl::kAllGraphicsShaderTypes) + { + gl::Shader *shader = shaders[shaderType]; + if (!shader) + { + continue; + } + + if (FindFlatInterpolationVaryingPerShader(context, shader)) + { + return true; + } + } + + return false; +} + +// Helper class that gathers uniform info from the default uniform block. +class UniformEncodingVisitorD3D : public sh::BlockEncoderVisitor +{ + public: + UniformEncodingVisitorD3D(gl::ShaderType shaderType, + HLSLRegisterType registerType, + sh::BlockLayoutEncoder *encoder, + D3DUniformMap *uniformMapOut) + : sh::BlockEncoderVisitor("", "", encoder), + mShaderType(shaderType), + mRegisterType(registerType), + mUniformMapOut(uniformMapOut) + {} + + void visitNamedOpaqueObject(const sh::ShaderVariable &sampler, + const std::string &name, + const std::string &mappedName, + const std::vector<unsigned int> &arraySizes) override + { + auto uniformMapEntry = mUniformMapOut->find(name); + if (uniformMapEntry == mUniformMapOut->end()) + { + (*mUniformMapOut)[name] = + new D3DUniform(sampler.type, mRegisterType, name, sampler.arraySizes, true); + } + } + + void encodeVariable(const sh::ShaderVariable &variable, + const sh::BlockMemberInfo &variableInfo, + const std::string &name, + const std::string &mappedName) override + { + auto uniformMapEntry = mUniformMapOut->find(name); + D3DUniform *d3dUniform = nullptr; + + if (uniformMapEntry != mUniformMapOut->end()) + { + d3dUniform = uniformMapEntry->second; + } + else + { + d3dUniform = + new D3DUniform(variable.type, mRegisterType, name, variable.arraySizes, true); + (*mUniformMapOut)[name] = d3dUniform; + } + + d3dUniform->registerElement = static_cast<unsigned int>( + sh::BlockLayoutEncoder::GetBlockRegisterElement(variableInfo)); + unsigned int reg = + static_cast<unsigned int>(sh::BlockLayoutEncoder::GetBlockRegister(variableInfo)); + + ASSERT(mShaderType != gl::ShaderType::InvalidEnum); + d3dUniform->mShaderRegisterIndexes[mShaderType] = reg; + } + + private: + gl::ShaderType mShaderType; + HLSLRegisterType mRegisterType; + D3DUniformMap *mUniformMapOut; +}; + +class HLSLBlockLayoutEncoderFactory : public gl::CustomBlockLayoutEncoderFactory +{ + public: + sh::BlockLayoutEncoder *makeEncoder() override + { + return new sh::HLSLBlockEncoder(sh::HLSLBlockEncoder::ENCODE_PACKED, false); + } +}; +} // anonymous namespace + +// D3DUniform Implementation + +D3DUniform::D3DUniform(GLenum type, + HLSLRegisterType reg, + const std::string &nameIn, + const std::vector<unsigned int> &arraySizesIn, + bool defaultBlock) + : typeInfo(gl::GetUniformTypeInfo(type)), + name(nameIn), + arraySizes(arraySizesIn), + mShaderData({}), + regType(reg), + registerCount(0), + registerElement(0) +{ + mShaderRegisterIndexes.fill(GL_INVALID_INDEX); + + // We use data storage for default block uniforms to cache values that are sent to D3D during + // rendering + // Uniform blocks/buffers are treated separately by the Renderer (ES3 path only) + if (defaultBlock) + { + // Use the row count as register count, will work for non-square matrices. + registerCount = typeInfo.rowCount * getArraySizeProduct(); + } +} + +D3DUniform::~D3DUniform() {} + +unsigned int D3DUniform::getArraySizeProduct() const +{ + return gl::ArraySizeProduct(arraySizes); +} + +const uint8_t *D3DUniform::getDataPtrToElement(size_t elementIndex) const +{ + ASSERT((!isArray() && elementIndex == 0) || + (isArray() && elementIndex < getArraySizeProduct())); + + if (isSampler()) + { + return reinterpret_cast<const uint8_t *>(&mSamplerData[elementIndex]); + } + + return firstNonNullData() + (elementIndex > 0 ? (typeInfo.internalSize * elementIndex) : 0u); +} + +bool D3DUniform::isSampler() const +{ + return typeInfo.isSampler; +} + +bool D3DUniform::isImage() const +{ + return typeInfo.isImageType; +} + +bool D3DUniform::isImage2D() const +{ + return gl::IsImage2DType(typeInfo.type); +} + +bool D3DUniform::isReferencedByShader(gl::ShaderType shaderType) const +{ + return mShaderRegisterIndexes[shaderType] != GL_INVALID_INDEX; +} + +const uint8_t *D3DUniform::firstNonNullData() const +{ + if (!mSamplerData.empty()) + { + return reinterpret_cast<const uint8_t *>(mSamplerData.data()); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (mShaderData[shaderType]) + { + return mShaderData[shaderType]; + } + } + + UNREACHABLE(); + return nullptr; +} + +// D3DInterfaceBlock Implementation +D3DInterfaceBlock::D3DInterfaceBlock() +{ + mShaderRegisterIndexes.fill(GL_INVALID_INDEX); +} + +D3DInterfaceBlock::D3DInterfaceBlock(const D3DInterfaceBlock &other) = default; + +D3DUniformBlock::D3DUniformBlock() +{ + mUseStructuredBuffers.fill(false); + mByteWidths.fill(0u); + mStructureByteStrides.fill(0u); +} + +D3DUniformBlock::D3DUniformBlock(const D3DUniformBlock &other) = default; + +// D3DVarying Implementation + +D3DVarying::D3DVarying() : semanticIndex(0), componentCount(0), outputSlot(0) {} + +D3DVarying::D3DVarying(const std::string &semanticNameIn, + unsigned int semanticIndexIn, + unsigned int componentCountIn, + unsigned int outputSlotIn) + : semanticName(semanticNameIn), + semanticIndex(semanticIndexIn), + componentCount(componentCountIn), + outputSlot(outputSlotIn) +{} + +// ProgramD3DMetadata Implementation + +ProgramD3DMetadata::ProgramD3DMetadata(RendererD3D *renderer, + const gl::ShaderMap<const ShaderD3D *> &attachedShaders, + EGLenum clientType) + : mRendererMajorShaderModel(renderer->getMajorShaderModel()), + mShaderModelSuffix(renderer->getShaderModelSuffix()), + mUsesInstancedPointSpriteEmulation( + renderer->getFeatures().useInstancedPointSpriteEmulation.enabled), + mUsesViewScale(renderer->presentPathFastEnabled()), + mCanSelectViewInVertexShader(renderer->canSelectViewInVertexShader()), + mAttachedShaders(attachedShaders), + mClientType(clientType) +{} + +ProgramD3DMetadata::~ProgramD3DMetadata() = default; + +int ProgramD3DMetadata::getRendererMajorShaderModel() const +{ + return mRendererMajorShaderModel; +} + +bool ProgramD3DMetadata::usesBroadcast(const gl::State &data) const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesFragColor() && shader->usesMultipleRenderTargets() && + data.getClientMajorVersion() < 3); +} + +bool ProgramD3DMetadata::usesSecondaryColor() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesSecondaryColor()); +} + +bool ProgramD3DMetadata::usesFragDepth() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesFragDepth()); +} + +bool ProgramD3DMetadata::usesPointCoord() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesPointCoord()); +} + +bool ProgramD3DMetadata::usesFragCoord() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesFragCoord()); +} + +bool ProgramD3DMetadata::usesPointSize() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Vertex]; + return (shader && shader->usesPointSize()); +} + +bool ProgramD3DMetadata::usesInsertedPointCoordValue() const +{ + return (!usesPointSize() || !mUsesInstancedPointSpriteEmulation) && usesPointCoord() && + mRendererMajorShaderModel >= 4; +} + +bool ProgramD3DMetadata::usesViewScale() const +{ + return mUsesViewScale; +} + +bool ProgramD3DMetadata::hasANGLEMultiviewEnabled() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Vertex]; + return (shader && shader->hasANGLEMultiviewEnabled()); +} + +bool ProgramD3DMetadata::usesVertexID() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Vertex]; + return (shader && shader->usesVertexID()); +} + +bool ProgramD3DMetadata::usesViewID() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesViewID()); +} + +bool ProgramD3DMetadata::canSelectViewInVertexShader() const +{ + return mCanSelectViewInVertexShader; +} + +bool ProgramD3DMetadata::addsPointCoordToVertexShader() const +{ + // PointSprite emulation requiress that gl_PointCoord is present in the vertex shader + // VS_OUTPUT structure to ensure compatibility with the generated PS_INPUT of the pixel shader. + // Even with a geometry shader, the app can render triangles or lines and reference + // gl_PointCoord in the fragment shader, requiring us to provide a placeholder value. For + // simplicity, we always add this to the vertex shader when the fragment shader + // references gl_PointCoord, even if we could skip it in the geometry shader. + return (mUsesInstancedPointSpriteEmulation && usesPointCoord()) || + usesInsertedPointCoordValue(); +} + +bool ProgramD3DMetadata::usesTransformFeedbackGLPosition() const +{ + // gl_Position only needs to be outputted from the vertex shader if transform feedback is + // active. This isn't supported on D3D11 Feature Level 9_3, so we don't output gl_Position from + // the vertex shader in this case. This saves us 1 output vector. + return !(mRendererMajorShaderModel >= 4 && mShaderModelSuffix != ""); +} + +bool ProgramD3DMetadata::usesSystemValuePointSize() const +{ + return !mUsesInstancedPointSpriteEmulation && usesPointSize(); +} + +bool ProgramD3DMetadata::usesMultipleFragmentOuts() const +{ + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Fragment]; + return (shader && shader->usesMultipleRenderTargets()); +} + +bool ProgramD3DMetadata::usesCustomOutVars() const +{ + + const rx::ShaderD3D *shader = mAttachedShaders[gl::ShaderType::Vertex]; + int version = shader ? shader->getState().getShaderVersion() : -1; + + switch (mClientType) + { + case EGL_OPENGL_API: + return version >= 130; + default: + return version >= 300; + } +} + +const ShaderD3D *ProgramD3DMetadata::getFragmentShader() const +{ + return mAttachedShaders[gl::ShaderType::Fragment]; +} + +// ProgramD3D::GetExecutableTask class +class ProgramD3D::GetExecutableTask : public Closure, public d3d::Context +{ + public: + GetExecutableTask(const gl::Context *context, ProgramD3D *program) + : mProgram(program), mContext(context) + {} + + virtual angle::Result run() = 0; + + void operator()() override { mResult = run(); } + + angle::Result getResult() const { return mResult; } + const gl::InfoLog &getInfoLog() const { return mInfoLog; } + ShaderExecutableD3D *getExecutable() { return mExecutable; } + + void handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) override + { + mStoredHR = hr; + mStoredMessage = message; + mStoredFile = file; + mStoredFunction = function; + mStoredLine = line; + } + + void popError(d3d::Context *context) + { + ASSERT(mStoredFile); + ASSERT(mStoredFunction); + context->handleResult(mStoredHR, mStoredMessage.c_str(), mStoredFile, mStoredFunction, + mStoredLine); + } + + protected: + ProgramD3D *mProgram = nullptr; + angle::Result mResult = angle::Result::Continue; + gl::InfoLog mInfoLog; + ShaderExecutableD3D *mExecutable = nullptr; + HRESULT mStoredHR = S_OK; + std::string mStoredMessage; + const char *mStoredFile = nullptr; + const char *mStoredFunction = nullptr; + unsigned int mStoredLine = 0; + const gl::Context *mContext = nullptr; +}; + +// ProgramD3D Implementation + +ProgramD3D::VertexExecutable::VertexExecutable(const gl::InputLayout &inputLayout, + const Signature &signature, + ShaderExecutableD3D *shaderExecutable) + : mInputs(inputLayout), mSignature(signature), mShaderExecutable(shaderExecutable) +{} + +ProgramD3D::VertexExecutable::~VertexExecutable() +{ + SafeDelete(mShaderExecutable); +} + +// static +ProgramD3D::VertexExecutable::HLSLAttribType ProgramD3D::VertexExecutable::GetAttribType( + GLenum type) +{ + switch (type) + { + case GL_INT: + return HLSLAttribType::SIGNED_INT; + case GL_UNSIGNED_INT: + return HLSLAttribType::UNSIGNED_INT; + case GL_SIGNED_NORMALIZED: + case GL_UNSIGNED_NORMALIZED: + case GL_FLOAT: + return HLSLAttribType::FLOAT; + default: + UNREACHABLE(); + return HLSLAttribType::FLOAT; + } +} + +// static +void ProgramD3D::VertexExecutable::getSignature(RendererD3D *renderer, + const gl::InputLayout &inputLayout, + Signature *signatureOut) +{ + signatureOut->assign(inputLayout.size(), HLSLAttribType::FLOAT); + + for (size_t index = 0; index < inputLayout.size(); ++index) + { + angle::FormatID vertexFormatID = inputLayout[index]; + if (vertexFormatID == angle::FormatID::NONE) + continue; + + VertexConversionType conversionType = renderer->getVertexConversionType(vertexFormatID); + if ((conversionType & VERTEX_CONVERT_GPU) == 0) + continue; + + GLenum componentType = renderer->getVertexComponentType(vertexFormatID); + (*signatureOut)[index] = GetAttribType(componentType); + } +} + +bool ProgramD3D::VertexExecutable::matchesSignature(const Signature &signature) const +{ + size_t limit = std::max(mSignature.size(), signature.size()); + for (size_t index = 0; index < limit; ++index) + { + // treat undefined indexes as FLOAT + auto a = index < signature.size() ? signature[index] : HLSLAttribType::FLOAT; + auto b = index < mSignature.size() ? mSignature[index] : HLSLAttribType::FLOAT; + if (a != b) + return false; + } + + return true; +} + +ProgramD3D::PixelExecutable::PixelExecutable(const std::vector<GLenum> &outputSignature, + ShaderExecutableD3D *shaderExecutable) + : mOutputSignature(outputSignature), mShaderExecutable(shaderExecutable) +{} + +ProgramD3D::PixelExecutable::~PixelExecutable() +{ + SafeDelete(mShaderExecutable); +} + +ProgramD3D::ComputeExecutable::ComputeExecutable( + const gl::ImageUnitTextureTypeMap &signature, + std::unique_ptr<ShaderExecutableD3D> shaderExecutable) + : mSignature(signature), mShaderExecutable(std::move(shaderExecutable)) +{} + +ProgramD3D::ComputeExecutable::~ComputeExecutable() {} + +ProgramD3D::Sampler::Sampler() + : active(false), logicalTextureUnit(0), textureType(gl::TextureType::_2D) +{} + +ProgramD3D::Image::Image() : active(false), logicalImageUnit(0) {} + +unsigned int ProgramD3D::mCurrentSerial = 1; + +ProgramD3D::ProgramD3D(const gl::ProgramState &state, RendererD3D *renderer) + : ProgramImpl(state), + mRenderer(renderer), + mDynamicHLSL(nullptr), + mUsesPointSize(false), + mUsesFlatInterpolation(false), + mUsedShaderSamplerRanges({}), + mDirtySamplerMapping(true), + mUsedImageRange({}), + mUsedReadonlyImageRange({}), + mUsedAtomicCounterRange({}), + mSerial(issueSerial()) +{ + mDynamicHLSL = new DynamicHLSL(renderer); +} + +ProgramD3D::~ProgramD3D() +{ + reset(); + SafeDelete(mDynamicHLSL); +} + +bool ProgramD3D::usesPointSpriteEmulation() const +{ + return mUsesPointSize && mRenderer->getMajorShaderModel() >= 4; +} + +bool ProgramD3D::usesGeometryShaderForPointSpriteEmulation() const +{ + return usesPointSpriteEmulation() && !usesInstancedPointSpriteEmulation(); +} + +bool ProgramD3D::usesGetDimensionsIgnoresBaseLevel() const +{ + return mRenderer->getFeatures().getDimensionsIgnoresBaseLevel.enabled; +} + +bool ProgramD3D::usesGeometryShader(const gl::State &state, const gl::PrimitiveMode drawMode) const +{ + if (mHasANGLEMultiviewEnabled && !mRenderer->canSelectViewInVertexShader()) + { + return true; + } + if (drawMode != gl::PrimitiveMode::Points) + { + if (!mUsesFlatInterpolation) + { + return false; + } + return state.getProvokingVertex() == gl::ProvokingVertexConvention::LastVertexConvention; + } + return usesGeometryShaderForPointSpriteEmulation(); +} + +bool ProgramD3D::usesInstancedPointSpriteEmulation() const +{ + return mRenderer->getFeatures().useInstancedPointSpriteEmulation.enabled; +} + +GLint ProgramD3D::getSamplerMapping(gl::ShaderType type, + unsigned int samplerIndex, + const gl::Caps &caps) const +{ + GLint logicalTextureUnit = -1; + + ASSERT(type != gl::ShaderType::InvalidEnum); + + ASSERT(samplerIndex < static_cast<unsigned int>(caps.maxShaderTextureImageUnits[type])); + + const auto &samplers = mShaderSamplers[type]; + if (samplerIndex < samplers.size() && samplers[samplerIndex].active) + { + logicalTextureUnit = samplers[samplerIndex].logicalTextureUnit; + } + + if (logicalTextureUnit >= 0 && logicalTextureUnit < caps.maxCombinedTextureImageUnits) + { + return logicalTextureUnit; + } + + return -1; +} + +// Returns the texture type for a given Direct3D 9 sampler type and +// index (0-15 for the pixel shader and 0-3 for the vertex shader). +gl::TextureType ProgramD3D::getSamplerTextureType(gl::ShaderType type, + unsigned int samplerIndex) const +{ + ASSERT(type != gl::ShaderType::InvalidEnum); + + const auto &samplers = mShaderSamplers[type]; + ASSERT(samplerIndex < samplers.size()); + ASSERT(samplers[samplerIndex].active); + + return samplers[samplerIndex].textureType; +} + +gl::RangeUI ProgramD3D::getUsedSamplerRange(gl::ShaderType type) const +{ + ASSERT(type != gl::ShaderType::InvalidEnum); + return mUsedShaderSamplerRanges[type]; +} + +ProgramD3D::SamplerMapping ProgramD3D::updateSamplerMapping() +{ + if (!mDirtySamplerMapping) + { + return SamplerMapping::WasClean; + } + + mDirtySamplerMapping = false; + + // Retrieve sampler uniform values + for (const D3DUniform *d3dUniform : mD3DUniforms) + { + if (!d3dUniform->isSampler()) + continue; + + int count = d3dUniform->getArraySizeProduct(); + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (!d3dUniform->isReferencedByShader(shaderType)) + { + continue; + } + + unsigned int firstIndex = d3dUniform->mShaderRegisterIndexes[shaderType]; + + std::vector<Sampler> &samplers = mShaderSamplers[shaderType]; + for (int i = 0; i < count; i++) + { + unsigned int samplerIndex = firstIndex + i; + + if (samplerIndex < samplers.size()) + { + ASSERT(samplers[samplerIndex].active); + samplers[samplerIndex].logicalTextureUnit = d3dUniform->mSamplerData[i]; + } + } + } + } + + return SamplerMapping::WasDirty; +} + +GLint ProgramD3D::getImageMapping(gl::ShaderType type, + unsigned int imageIndex, + bool readonly, + const gl::Caps &caps) const +{ + GLint logicalImageUnit = -1; + ASSERT(imageIndex < static_cast<unsigned int>(caps.maxImageUnits)); + if (readonly && imageIndex < mReadonlyImages[type].size() && + mReadonlyImages[type][imageIndex].active) + { + logicalImageUnit = mReadonlyImages[type][imageIndex].logicalImageUnit; + } + else if (imageIndex < mImages[type].size() && mImages[type][imageIndex].active) + { + logicalImageUnit = mImages[type][imageIndex].logicalImageUnit; + } + + if (logicalImageUnit >= 0 && logicalImageUnit < caps.maxImageUnits) + { + return logicalImageUnit; + } + + return -1; +} + +gl::RangeUI ProgramD3D::getUsedImageRange(gl::ShaderType type, bool readonly) const +{ + return readonly ? mUsedReadonlyImageRange[type] : mUsedImageRange[type]; +} + +class ProgramD3D::LoadBinaryTask : public ProgramD3D::GetExecutableTask +{ + public: + LoadBinaryTask(const gl::Context *context, + ProgramD3D *program, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog) + : ProgramD3D::GetExecutableTask(context, program) + { + ASSERT(mProgram); + ASSERT(stream); + + // Copy the remaining data from the stream locally so that the client can't modify it when + // loading off thread. + size_t dataSize = stream->remainingSize(); + mDataCopySucceeded = mStreamData.resize(dataSize); + if (mDataCopySucceeded) + { + memcpy(mStreamData.data(), stream->data() + stream->offset(), dataSize); + } + } + + angle::Result run() override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::LoadBinaryTask::run"); + if (!mDataCopySucceeded) + { + mInfoLog << "Failed to copy program binary data to local buffer."; + return angle::Result::Incomplete; + } + + gl::BinaryInputStream stream(mStreamData.data(), mStreamData.size()); + return mProgram->loadBinaryShaderExecutables(this, &stream, mInfoLog); + } + + private: + bool mDataCopySucceeded; + angle::MemoryBuffer mStreamData; +}; + +class ProgramD3D::LoadBinaryLinkEvent final : public LinkEvent +{ + public: + LoadBinaryLinkEvent(const gl::Context *context, + std::shared_ptr<WorkerThreadPool> workerPool, + ProgramD3D *program, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog) + : mTask(std::make_shared<ProgramD3D::LoadBinaryTask>(context, program, stream, infoLog)), + mWaitableEvent(angle::WorkerThreadPool::PostWorkerTask(workerPool, mTask)) + {} + + angle::Result wait(const gl::Context *context) override + { + mWaitableEvent->wait(); + + // Continue and Incomplete are not errors. For Stop, pass the error to the ContextD3D. + if (mTask->getResult() != angle::Result::Stop) + { + return angle::Result::Continue; + } + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + mTask->popError(contextD3D); + return angle::Result::Stop; + } + + bool isLinking() override { return !mWaitableEvent->isReady(); } + + private: + std::shared_ptr<ProgramD3D::LoadBinaryTask> mTask; + std::shared_ptr<WaitableEvent> mWaitableEvent; +}; + +std::unique_ptr<rx::LinkEvent> ProgramD3D::load(const gl::Context *context, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog) +{ + + // TODO(jmadill): Use Renderer from contextImpl. + + reset(); + + DeviceIdentifier binaryDeviceIdentifier = {}; + stream->readBytes(reinterpret_cast<unsigned char *>(&binaryDeviceIdentifier), + sizeof(DeviceIdentifier)); + + DeviceIdentifier identifier = mRenderer->getAdapterIdentifier(); + if (memcmp(&identifier, &binaryDeviceIdentifier, sizeof(DeviceIdentifier)) != 0) + { + infoLog << "Invalid program binary, device configuration has changed."; + return nullptr; + } + + int compileFlags = stream->readInt<int>(); + if (compileFlags != ANGLE_COMPILE_OPTIMIZATION_LEVEL) + { + infoLog << "Mismatched compilation flags."; + return nullptr; + } + + for (int &index : mAttribLocationToD3DSemantic) + { + stream->readInt(&index); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + size_t samplerCount = stream->readInt<size_t>(); + for (size_t sampleIndex = 0; sampleIndex < samplerCount; ++sampleIndex) + { + Sampler sampler; + stream->readBool(&sampler.active); + stream->readInt(&sampler.logicalTextureUnit); + stream->readEnum(&sampler.textureType); + mShaderSamplers[shaderType].push_back(sampler); + } + + unsigned int samplerRangeLow, samplerRangeHigh; + stream->readInt(&samplerRangeLow); + stream->readInt(&samplerRangeHigh); + mUsedShaderSamplerRanges[shaderType] = gl::RangeUI(samplerRangeLow, samplerRangeHigh); + } + + for (gl::ShaderType shaderType : {gl::ShaderType::Compute, gl::ShaderType::Fragment}) + { + size_t imageCount = stream->readInt<size_t>(); + for (size_t imageIndex = 0; imageIndex < imageCount; ++imageIndex) + { + Image image; + stream->readBool(&image.active); + stream->readInt(&image.logicalImageUnit); + mImages[shaderType].push_back(image); + } + + size_t readonlyImageCount = stream->readInt<size_t>(); + for (size_t imageIndex = 0; imageIndex < readonlyImageCount; ++imageIndex) + { + Image image; + stream->readBool(&image.active); + stream->readInt(&image.logicalImageUnit); + mReadonlyImages[shaderType].push_back(image); + } + + unsigned int imageRangeLow, imageRangeHigh, readonlyImageRangeLow, readonlyImageRangeHigh; + stream->readInt(&imageRangeLow); + stream->readInt(&imageRangeHigh); + stream->readInt(&readonlyImageRangeLow); + stream->readInt(&readonlyImageRangeHigh); + mUsedImageRange[shaderType] = gl::RangeUI(imageRangeLow, imageRangeHigh); + mUsedReadonlyImageRange[shaderType] = + gl::RangeUI(readonlyImageRangeLow, readonlyImageRangeHigh); + + unsigned int atomicCounterRangeLow, atomicCounterRangeHigh; + stream->readInt(&atomicCounterRangeLow); + stream->readInt(&atomicCounterRangeHigh); + mUsedAtomicCounterRange[shaderType] = + gl::RangeUI(atomicCounterRangeLow, atomicCounterRangeHigh); + } + + size_t shaderStorageBlockCount = stream->readInt<size_t>(); + if (stream->error()) + { + infoLog << "Invalid program binary."; + return nullptr; + } + + ASSERT(mD3DShaderStorageBlocks.empty()); + for (size_t blockIndex = 0; blockIndex < shaderStorageBlockCount; ++blockIndex) + { + D3DInterfaceBlock shaderStorageBlock; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->readInt(&shaderStorageBlock.mShaderRegisterIndexes[shaderType]); + } + mD3DShaderStorageBlocks.push_back(shaderStorageBlock); + } + + for (gl::ShaderType shaderType : {gl::ShaderType::Compute, gl::ShaderType::Fragment}) + { + size_t image2DUniformCount = stream->readInt<size_t>(); + if (stream->error()) + { + infoLog << "Invalid program binary."; + return nullptr; + } + + ASSERT(mImage2DUniforms[shaderType].empty()); + for (size_t image2DUniformIndex = 0; image2DUniformIndex < image2DUniformCount; + ++image2DUniformIndex) + { + sh::ShaderVariable image2Duniform; + gl::LoadShaderVar(stream, &image2Duniform); + mImage2DUniforms[shaderType].push_back(image2Duniform); + } + } + + for (unsigned int ii = 0; ii < gl::IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS; ++ii) + { + unsigned int index = stream->readInt<unsigned int>(); + mComputeAtomicCounterBufferRegisterIndices[ii] = index; + } + + size_t uniformCount = stream->readInt<size_t>(); + if (stream->error()) + { + infoLog << "Invalid program binary."; + return nullptr; + } + + const auto &linkedUniforms = mState.getUniforms(); + ASSERT(mD3DUniforms.empty()); + for (size_t uniformIndex = 0; uniformIndex < uniformCount; uniformIndex++) + { + const gl::LinkedUniform &linkedUniform = linkedUniforms[uniformIndex]; + + D3DUniform *d3dUniform = + new D3DUniform(linkedUniform.type, HLSLRegisterType::None, linkedUniform.name, + linkedUniform.arraySizes, linkedUniform.isInDefaultBlock()); + stream->readEnum(&d3dUniform->regType); + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->readInt(&d3dUniform->mShaderRegisterIndexes[shaderType]); + } + stream->readInt(&d3dUniform->registerCount); + stream->readInt(&d3dUniform->registerElement); + + mD3DUniforms.push_back(d3dUniform); + } + + size_t blockCount = stream->readInt<size_t>(); + if (stream->error()) + { + infoLog << "Invalid program binary."; + return nullptr; + } + + ASSERT(mD3DUniformBlocks.empty()); + for (size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex) + { + D3DUniformBlock uniformBlock; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->readInt(&uniformBlock.mShaderRegisterIndexes[shaderType]); + stream->readBool(&uniformBlock.mUseStructuredBuffers[shaderType]); + stream->readInt(&uniformBlock.mByteWidths[shaderType]); + stream->readInt(&uniformBlock.mStructureByteStrides[shaderType]); + } + mD3DUniformBlocks.push_back(uniformBlock); + } + + size_t streamOutVaryingCount = stream->readInt<size_t>(); + mStreamOutVaryings.resize(streamOutVaryingCount); + for (size_t varyingIndex = 0; varyingIndex < streamOutVaryingCount; ++varyingIndex) + { + D3DVarying *varying = &mStreamOutVaryings[varyingIndex]; + + stream->readString(&varying->semanticName); + stream->readInt(&varying->semanticIndex); + stream->readInt(&varying->componentCount); + stream->readInt(&varying->outputSlot); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->readString(&mShaderHLSL[shaderType]); + stream->readBytes(reinterpret_cast<unsigned char *>(&mShaderWorkarounds[shaderType]), + sizeof(CompilerWorkaroundsD3D)); + } + + stream->readBool(&mUsesFragDepth); + stream->readBool(&mHasANGLEMultiviewEnabled); + stream->readBool(&mUsesVertexID); + stream->readBool(&mUsesViewID); + stream->readBool(&mUsesPointSize); + stream->readBool(&mUsesFlatInterpolation); + + const size_t pixelShaderKeySize = stream->readInt<size_t>(); + mPixelShaderKey.resize(pixelShaderKeySize); + for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKeySize; + pixelShaderKeyIndex++) + { + stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].type); + stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].name); + stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].source); + stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].outputLocation); + stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].outputIndex); + } + + stream->readString(&mGeometryShaderPreamble); + + return std::make_unique<LoadBinaryLinkEvent>(context, context->getWorkerThreadPool(), this, + stream, infoLog); +} + +angle::Result ProgramD3D::loadBinaryShaderExecutables(d3d::Context *contextD3D, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog) +{ + const unsigned char *binary = reinterpret_cast<const unsigned char *>(stream->data()); + + bool separateAttribs = (mState.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS); + + size_t vertexShaderCount = stream->readInt<size_t>(); + for (size_t vertexShaderIndex = 0; vertexShaderIndex < vertexShaderCount; vertexShaderIndex++) + { + size_t inputLayoutSize = stream->readInt<size_t>(); + gl::InputLayout inputLayout(inputLayoutSize, angle::FormatID::NONE); + + for (size_t inputIndex = 0; inputIndex < inputLayoutSize; inputIndex++) + { + inputLayout[inputIndex] = stream->readEnum<angle::FormatID>(); + } + + size_t vertexShaderSize = stream->readInt<size_t>(); + const unsigned char *vertexShaderFunction = binary + stream->offset(); + + ShaderExecutableD3D *shaderExecutable = nullptr; + + ANGLE_TRY(mRenderer->loadExecutable(contextD3D, vertexShaderFunction, vertexShaderSize, + gl::ShaderType::Vertex, mStreamOutVaryings, + separateAttribs, &shaderExecutable)); + + if (!shaderExecutable) + { + infoLog << "Could not create vertex shader."; + return angle::Result::Incomplete; + } + + // generated converted input layout + VertexExecutable::Signature signature; + VertexExecutable::getSignature(mRenderer, inputLayout, &signature); + + // add new binary + mVertexExecutables.push_back(std::unique_ptr<VertexExecutable>( + new VertexExecutable(inputLayout, signature, shaderExecutable))); + + stream->skip(vertexShaderSize); + } + + size_t pixelShaderCount = stream->readInt<size_t>(); + for (size_t pixelShaderIndex = 0; pixelShaderIndex < pixelShaderCount; pixelShaderIndex++) + { + size_t outputCount = stream->readInt<size_t>(); + std::vector<GLenum> outputs(outputCount); + for (size_t outputIndex = 0; outputIndex < outputCount; outputIndex++) + { + stream->readInt(&outputs[outputIndex]); + } + + size_t pixelShaderSize = stream->readInt<size_t>(); + const unsigned char *pixelShaderFunction = binary + stream->offset(); + ShaderExecutableD3D *shaderExecutable = nullptr; + + ANGLE_TRY(mRenderer->loadExecutable(contextD3D, pixelShaderFunction, pixelShaderSize, + gl::ShaderType::Fragment, mStreamOutVaryings, + separateAttribs, &shaderExecutable)); + + if (!shaderExecutable) + { + infoLog << "Could not create pixel shader."; + return angle::Result::Incomplete; + } + + // add new binary + mPixelExecutables.push_back( + std::unique_ptr<PixelExecutable>(new PixelExecutable(outputs, shaderExecutable))); + + stream->skip(pixelShaderSize); + } + + for (std::unique_ptr<ShaderExecutableD3D> &geometryExe : mGeometryExecutables) + { + size_t geometryShaderSize = stream->readInt<size_t>(); + if (geometryShaderSize == 0) + { + continue; + } + + const unsigned char *geometryShaderFunction = binary + stream->offset(); + + ShaderExecutableD3D *geometryExecutable = nullptr; + ANGLE_TRY(mRenderer->loadExecutable(contextD3D, geometryShaderFunction, geometryShaderSize, + gl::ShaderType::Geometry, mStreamOutVaryings, + separateAttribs, &geometryExecutable)); + + if (!geometryExecutable) + { + infoLog << "Could not create geometry shader."; + return angle::Result::Incomplete; + } + + geometryExe.reset(geometryExecutable); + + stream->skip(geometryShaderSize); + } + + size_t computeShaderCount = stream->readInt<size_t>(); + for (size_t computeShaderIndex = 0; computeShaderIndex < computeShaderCount; + computeShaderIndex++) + { + size_t signatureCount = stream->readInt<size_t>(); + gl::ImageUnitTextureTypeMap signatures; + for (size_t signatureIndex = 0; signatureIndex < signatureCount; signatureIndex++) + { + unsigned int imageUint; + gl::TextureType textureType; + stream->readInt(&imageUint); + stream->readEnum(&textureType); + signatures.insert(std::pair<unsigned int, gl::TextureType>(imageUint, textureType)); + } + + size_t computeShaderSize = stream->readInt<size_t>(); + const unsigned char *computeShaderFunction = binary + stream->offset(); + + ShaderExecutableD3D *computeExecutable = nullptr; + ANGLE_TRY(mRenderer->loadExecutable(contextD3D, computeShaderFunction, computeShaderSize, + gl::ShaderType::Compute, std::vector<D3DVarying>(), + false, &computeExecutable)); + + if (!computeExecutable) + { + infoLog << "Could not create compute shader."; + return angle::Result::Incomplete; + } + + // add new binary + mComputeExecutables.push_back(std::unique_ptr<ComputeExecutable>(new ComputeExecutable( + signatures, std::unique_ptr<ShaderExecutableD3D>(computeExecutable)))); + + stream->skip(computeShaderSize); + } + + size_t bindLayoutCount = stream->readInt<size_t>(); + for (size_t bindLayoutIndex = 0; bindLayoutIndex < bindLayoutCount; bindLayoutIndex++) + { + mImage2DBindLayoutCache[gl::ShaderType::Compute].insert( + std::pair<unsigned int, gl::TextureType>(stream->readInt<unsigned int>(), + gl::TextureType::_2D)); + } + + initializeUniformStorage(mState.getExecutable().getLinkedShaderStages()); + + dirtyAllUniforms(); + + return angle::Result::Continue; +} + +void ProgramD3D::save(const gl::Context *context, gl::BinaryOutputStream *stream) +{ + // Output the DeviceIdentifier before we output any shader code + // When we load the binary again later, we can validate the device identifier before trying to + // compile any HLSL + DeviceIdentifier binaryIdentifier = mRenderer->getAdapterIdentifier(); + stream->writeBytes(reinterpret_cast<unsigned char *>(&binaryIdentifier), + sizeof(DeviceIdentifier)); + + stream->writeInt(ANGLE_COMPILE_OPTIMIZATION_LEVEL); + + for (int d3dSemantic : mAttribLocationToD3DSemantic) + { + stream->writeInt(d3dSemantic); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->writeInt(mShaderSamplers[shaderType].size()); + for (unsigned int i = 0; i < mShaderSamplers[shaderType].size(); ++i) + { + stream->writeBool(mShaderSamplers[shaderType][i].active); + stream->writeInt(mShaderSamplers[shaderType][i].logicalTextureUnit); + stream->writeEnum(mShaderSamplers[shaderType][i].textureType); + } + + stream->writeInt(mUsedShaderSamplerRanges[shaderType].low()); + stream->writeInt(mUsedShaderSamplerRanges[shaderType].high()); + } + + for (gl::ShaderType shaderType : {gl::ShaderType::Compute, gl::ShaderType::Fragment}) + { + stream->writeInt(mImages[shaderType].size()); + for (size_t imageIndex = 0; imageIndex < mImages[shaderType].size(); ++imageIndex) + { + stream->writeBool(mImages[shaderType][imageIndex].active); + stream->writeInt(mImages[shaderType][imageIndex].logicalImageUnit); + } + + stream->writeInt(mReadonlyImages[shaderType].size()); + for (size_t imageIndex = 0; imageIndex < mReadonlyImages[shaderType].size(); ++imageIndex) + { + stream->writeBool(mReadonlyImages[shaderType][imageIndex].active); + stream->writeInt(mReadonlyImages[shaderType][imageIndex].logicalImageUnit); + } + + stream->writeInt(mUsedImageRange[shaderType].low()); + stream->writeInt(mUsedImageRange[shaderType].high()); + stream->writeInt(mUsedReadonlyImageRange[shaderType].low()); + stream->writeInt(mUsedReadonlyImageRange[shaderType].high()); + stream->writeInt(mUsedAtomicCounterRange[shaderType].low()); + stream->writeInt(mUsedAtomicCounterRange[shaderType].high()); + } + + stream->writeInt(mD3DShaderStorageBlocks.size()); + for (const D3DInterfaceBlock &shaderStorageBlock : mD3DShaderStorageBlocks) + { + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->writeIntOrNegOne(shaderStorageBlock.mShaderRegisterIndexes[shaderType]); + } + } + + for (gl::ShaderType shaderType : {gl::ShaderType::Compute, gl::ShaderType::Fragment}) + { + stream->writeInt(mImage2DUniforms[shaderType].size()); + for (const sh::ShaderVariable &image2DUniform : mImage2DUniforms[shaderType]) + { + gl::WriteShaderVar(stream, image2DUniform); + } + } + + for (unsigned int ii = 0; ii < gl::IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS; ++ii) + { + stream->writeInt(mComputeAtomicCounterBufferRegisterIndices[ii]); + } + + stream->writeInt(mD3DUniforms.size()); + for (const D3DUniform *uniform : mD3DUniforms) + { + // Type, name and arraySize are redundant, so aren't stored in the binary. + stream->writeEnum(uniform->regType); + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->writeIntOrNegOne(uniform->mShaderRegisterIndexes[shaderType]); + } + stream->writeInt(uniform->registerCount); + stream->writeInt(uniform->registerElement); + } + + stream->writeInt(mD3DUniformBlocks.size()); + for (const D3DUniformBlock &uniformBlock : mD3DUniformBlocks) + { + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->writeIntOrNegOne(uniformBlock.mShaderRegisterIndexes[shaderType]); + stream->writeBool(uniformBlock.mUseStructuredBuffers[shaderType]); + stream->writeInt(uniformBlock.mByteWidths[shaderType]); + stream->writeInt(uniformBlock.mStructureByteStrides[shaderType]); + } + } + + stream->writeInt(mStreamOutVaryings.size()); + for (const D3DVarying &varying : mStreamOutVaryings) + { + stream->writeString(varying.semanticName); + stream->writeInt(varying.semanticIndex); + stream->writeInt(varying.componentCount); + stream->writeInt(varying.outputSlot); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + stream->writeString(mShaderHLSL[shaderType]); + stream->writeBytes(reinterpret_cast<unsigned char *>(&mShaderWorkarounds[shaderType]), + sizeof(CompilerWorkaroundsD3D)); + } + + stream->writeBool(mUsesFragDepth); + stream->writeBool(mHasANGLEMultiviewEnabled); + stream->writeBool(mUsesVertexID); + stream->writeBool(mUsesViewID); + stream->writeBool(mUsesPointSize); + stream->writeBool(mUsesFlatInterpolation); + + const std::vector<PixelShaderOutputVariable> &pixelShaderKey = mPixelShaderKey; + stream->writeInt(pixelShaderKey.size()); + for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKey.size(); + pixelShaderKeyIndex++) + { + const PixelShaderOutputVariable &variable = pixelShaderKey[pixelShaderKeyIndex]; + stream->writeInt(variable.type); + stream->writeString(variable.name); + stream->writeString(variable.source); + stream->writeInt(variable.outputLocation); + stream->writeInt(variable.outputIndex); + } + + stream->writeString(mGeometryShaderPreamble); + + stream->writeInt(mVertexExecutables.size()); + for (size_t vertexExecutableIndex = 0; vertexExecutableIndex < mVertexExecutables.size(); + vertexExecutableIndex++) + { + VertexExecutable *vertexExecutable = mVertexExecutables[vertexExecutableIndex].get(); + + const gl::InputLayout &inputLayout = vertexExecutable->inputs(); + stream->writeInt(inputLayout.size()); + + for (size_t inputIndex = 0; inputIndex < inputLayout.size(); inputIndex++) + { + stream->writeEnum(inputLayout[inputIndex]); + } + + size_t vertexShaderSize = vertexExecutable->shaderExecutable()->getLength(); + stream->writeInt(vertexShaderSize); + + const uint8_t *vertexBlob = vertexExecutable->shaderExecutable()->getFunction(); + stream->writeBytes(vertexBlob, vertexShaderSize); + } + + stream->writeInt(mPixelExecutables.size()); + for (size_t pixelExecutableIndex = 0; pixelExecutableIndex < mPixelExecutables.size(); + pixelExecutableIndex++) + { + PixelExecutable *pixelExecutable = mPixelExecutables[pixelExecutableIndex].get(); + + const std::vector<GLenum> &outputs = pixelExecutable->outputSignature(); + stream->writeInt(outputs.size()); + for (size_t outputIndex = 0; outputIndex < outputs.size(); outputIndex++) + { + stream->writeInt(outputs[outputIndex]); + } + + size_t pixelShaderSize = pixelExecutable->shaderExecutable()->getLength(); + stream->writeInt(pixelShaderSize); + + const uint8_t *pixelBlob = pixelExecutable->shaderExecutable()->getFunction(); + stream->writeBytes(pixelBlob, pixelShaderSize); + } + + for (auto const &geometryExecutable : mGeometryExecutables) + { + if (!geometryExecutable) + { + stream->writeInt<size_t>(0); + continue; + } + + size_t geometryShaderSize = geometryExecutable->getLength(); + stream->writeInt(geometryShaderSize); + stream->writeBytes(geometryExecutable->getFunction(), geometryShaderSize); + } + + stream->writeInt(mComputeExecutables.size()); + for (size_t computeExecutableIndex = 0; computeExecutableIndex < mComputeExecutables.size(); + computeExecutableIndex++) + { + ComputeExecutable *computeExecutable = mComputeExecutables[computeExecutableIndex].get(); + + const gl::ImageUnitTextureTypeMap signatures = computeExecutable->signature(); + stream->writeInt(signatures.size()); + for (const auto &signature : signatures) + { + stream->writeInt(signature.first); + stream->writeEnum(signature.second); + } + + size_t computeShaderSize = computeExecutable->shaderExecutable()->getLength(); + stream->writeInt(computeShaderSize); + + const uint8_t *computeBlob = computeExecutable->shaderExecutable()->getFunction(); + stream->writeBytes(computeBlob, computeShaderSize); + } + + for (gl::ShaderType shaderType : {gl::ShaderType::Compute}) + { + stream->writeInt(mImage2DBindLayoutCache[shaderType].size()); + for (auto &image2DBindLayout : mImage2DBindLayoutCache[shaderType]) + { + stream->writeInt(image2DBindLayout.first); + } + } +} + +void ProgramD3D::setBinaryRetrievableHint(bool /* retrievable */) {} + +void ProgramD3D::setSeparable(bool /* separable */) {} + +angle::Result ProgramD3D::getPixelExecutableForCachedOutputLayout( + d3d::Context *context, + ShaderExecutableD3D **outExecutable, + gl::InfoLog *infoLog) +{ + if (mCachedPixelExecutableIndex.valid()) + { + *outExecutable = mPixelExecutables[mCachedPixelExecutableIndex.value()]->shaderExecutable(); + return angle::Result::Continue; + } + + std::string pixelHLSL = mDynamicHLSL->generatePixelShaderForOutputSignature( + mShaderHLSL[gl::ShaderType::Fragment], mPixelShaderKey, mUsesFragDepth, + mPixelShaderOutputLayoutCache, mShaderStorageBlocks[gl::ShaderType::Fragment], + mPixelShaderKey.size()); + + std::string finalPixelHLSL = mDynamicHLSL->generateShaderForImage2DBindSignature( + *this, mState, gl::ShaderType::Fragment, pixelHLSL, + mImage2DUniforms[gl::ShaderType::Fragment], + mImage2DBindLayoutCache[gl::ShaderType::Fragment], + static_cast<unsigned int>(mPixelShaderKey.size())); + + // Generate new pixel executable + ShaderExecutableD3D *pixelExecutable = nullptr; + + gl::InfoLog tempInfoLog; + gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog; + + ANGLE_TRY(mRenderer->compileToExecutable( + context, *currentInfoLog, finalPixelHLSL, gl::ShaderType::Fragment, mStreamOutVaryings, + (mState.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), + mShaderWorkarounds[gl::ShaderType::Fragment], &pixelExecutable)); + + if (pixelExecutable) + { + mPixelExecutables.push_back(std::unique_ptr<PixelExecutable>( + new PixelExecutable(mPixelShaderOutputLayoutCache, pixelExecutable))); + mCachedPixelExecutableIndex = mPixelExecutables.size() - 1; + } + else if (!infoLog) + { + ERR() << "Error compiling dynamic pixel executable:" << std::endl + << tempInfoLog.str() << std::endl; + } + + *outExecutable = pixelExecutable; + return angle::Result::Continue; +} + +angle::Result ProgramD3D::getVertexExecutableForCachedInputLayout( + d3d::Context *context, + ShaderExecutableD3D **outExectuable, + gl::InfoLog *infoLog) +{ + if (mCachedVertexExecutableIndex.valid()) + { + *outExectuable = + mVertexExecutables[mCachedVertexExecutableIndex.value()]->shaderExecutable(); + return angle::Result::Continue; + } + + // Generate new dynamic layout with attribute conversions + std::string finalVertexHLSL = mDynamicHLSL->generateVertexShaderForInputLayout( + mShaderHLSL[gl::ShaderType::Vertex], mCachedInputLayout, mState.getProgramInputs(), + mShaderStorageBlocks[gl::ShaderType::Vertex], mPixelShaderKey.size()); + + // Generate new vertex executable + ShaderExecutableD3D *vertexExecutable = nullptr; + + gl::InfoLog tempInfoLog; + gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog; + + ANGLE_TRY(mRenderer->compileToExecutable( + context, *currentInfoLog, finalVertexHLSL, gl::ShaderType::Vertex, mStreamOutVaryings, + (mState.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), + mShaderWorkarounds[gl::ShaderType::Vertex], &vertexExecutable)); + + if (vertexExecutable) + { + mVertexExecutables.push_back(std::unique_ptr<VertexExecutable>( + new VertexExecutable(mCachedInputLayout, mCachedVertexSignature, vertexExecutable))); + mCachedVertexExecutableIndex = mVertexExecutables.size() - 1; + } + else if (!infoLog) + { + ERR() << "Error compiling dynamic vertex executable:" << std::endl + << tempInfoLog.str() << std::endl; + } + + *outExectuable = vertexExecutable; + return angle::Result::Continue; +} + +angle::Result ProgramD3D::getGeometryExecutableForPrimitiveType(d3d::Context *context, + const gl::State &state, + gl::PrimitiveMode drawMode, + ShaderExecutableD3D **outExecutable, + gl::InfoLog *infoLog) +{ + if (outExecutable) + { + *outExecutable = nullptr; + } + + // Return a null shader if the current rendering doesn't use a geometry shader + if (!usesGeometryShader(state, drawMode)) + { + return angle::Result::Continue; + } + + gl::PrimitiveMode geometryShaderType = GetGeometryShaderTypeFromDrawMode(drawMode); + + if (mGeometryExecutables[geometryShaderType]) + { + if (outExecutable) + { + *outExecutable = mGeometryExecutables[geometryShaderType].get(); + } + return angle::Result::Continue; + } + const gl::Caps &caps = state.getCaps(); + std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL( + caps, geometryShaderType, mState, mRenderer->presentPathFastEnabled(), + mHasANGLEMultiviewEnabled, mRenderer->canSelectViewInVertexShader(), + usesGeometryShaderForPointSpriteEmulation(), mGeometryShaderPreamble); + + gl::InfoLog tempInfoLog; + gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog; + + ShaderExecutableD3D *geometryExecutable = nullptr; + angle::Result result = mRenderer->compileToExecutable( + context, *currentInfoLog, geometryHLSL, gl::ShaderType::Geometry, mStreamOutVaryings, + (mState.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), CompilerWorkaroundsD3D(), + &geometryExecutable); + + if (!infoLog && result == angle::Result::Stop) + { + ERR() << "Error compiling dynamic geometry executable:" << std::endl + << tempInfoLog.str() << std::endl; + } + + if (geometryExecutable != nullptr) + { + mGeometryExecutables[geometryShaderType].reset(geometryExecutable); + } + + if (outExecutable) + { + *outExecutable = mGeometryExecutables[geometryShaderType].get(); + } + return result; +} + +class ProgramD3D::GetVertexExecutableTask : public ProgramD3D::GetExecutableTask +{ + public: + GetVertexExecutableTask(const gl::Context *context, ProgramD3D *program) + : GetExecutableTask(context, program) + {} + angle::Result run() override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetVertexExecutableTask::run"); + + ANGLE_TRY(mProgram->getVertexExecutableForCachedInputLayout(this, &mExecutable, &mInfoLog)); + + return angle::Result::Continue; + } +}; + +void ProgramD3D::updateCachedInputLayoutFromShader(const gl::Context *context) +{ + GetDefaultInputLayoutFromShader(context, mState.getAttachedShader(gl::ShaderType::Vertex), + &mCachedInputLayout); + VertexExecutable::getSignature(mRenderer, mCachedInputLayout, &mCachedVertexSignature); + updateCachedVertexExecutableIndex(); +} + +class ProgramD3D::GetPixelExecutableTask : public ProgramD3D::GetExecutableTask +{ + public: + GetPixelExecutableTask(const gl::Context *context, ProgramD3D *program) + : GetExecutableTask(context, program) + {} + angle::Result run() override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetPixelExecutableTask::run"); + if (!mProgram->mState.getAttachedShader(gl::ShaderType::Fragment)) + { + return angle::Result::Continue; + } + + mProgram->updateCachedOutputLayoutFromShader(); + mProgram->updateCachedImage2DBindLayoutFromShader(gl::ShaderType::Fragment); + ANGLE_TRY(mProgram->getPixelExecutableForCachedOutputLayout(this, &mExecutable, &mInfoLog)); + + return angle::Result::Continue; + } +}; + +void ProgramD3D::updateCachedOutputLayoutFromShader() +{ + GetDefaultOutputLayoutFromShader(mPixelShaderKey, &mPixelShaderOutputLayoutCache); + updateCachedPixelExecutableIndex(); +} + +void ProgramD3D::updateCachedImage2DBindLayoutFromShader(gl::ShaderType shaderType) +{ + GetDefaultImage2DBindLayoutFromShader(mImage2DUniforms[shaderType], + &mImage2DBindLayoutCache[shaderType]); + switch (shaderType) + { + case gl::ShaderType::Compute: + updateCachedComputeExecutableIndex(); + break; + case gl::ShaderType::Fragment: + updateCachedPixelExecutableIndex(); + break; + case gl::ShaderType::Vertex: + updateCachedVertexExecutableIndex(); + break; + default: + ASSERT(false); + break; + } +} + +class ProgramD3D::GetGeometryExecutableTask : public ProgramD3D::GetExecutableTask +{ + public: + GetGeometryExecutableTask(const gl::Context *context, + ProgramD3D *program, + const gl::State &state) + : GetExecutableTask(context, program), mState(state) + {} + + angle::Result run() override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetGeometryExecutableTask::run"); + // Auto-generate the geometry shader here, if we expect to be using point rendering in + // D3D11. + if (mProgram->usesGeometryShader(mState, gl::PrimitiveMode::Points)) + { + ANGLE_TRY(mProgram->getGeometryExecutableForPrimitiveType( + this, mState, gl::PrimitiveMode::Points, &mExecutable, &mInfoLog)); + } + + return angle::Result::Continue; + } + + private: + const gl::State &mState; +}; + +class ProgramD3D::GetComputeExecutableTask : public ProgramD3D::GetExecutableTask +{ + public: + GetComputeExecutableTask(const gl::Context *context, ProgramD3D *program) + : GetExecutableTask(context, program) + {} + angle::Result run() override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetComputeExecutableTask::run"); + mProgram->updateCachedImage2DBindLayoutFromShader(gl::ShaderType::Compute); + ShaderExecutableD3D *computeExecutable = nullptr; + ANGLE_TRY(mProgram->getComputeExecutableForImage2DBindLayout( + mContext, this, &computeExecutable, &mInfoLog)); + + return computeExecutable ? angle::Result::Continue : angle::Result::Incomplete; + } +}; + +// The LinkEvent implementation for linking a rendering(VS, FS, GS) program. +class ProgramD3D::GraphicsProgramLinkEvent final : public LinkEvent +{ + public: + GraphicsProgramLinkEvent(gl::InfoLog &infoLog, + std::shared_ptr<WorkerThreadPool> workerPool, + std::shared_ptr<ProgramD3D::GetVertexExecutableTask> vertexTask, + std::shared_ptr<ProgramD3D::GetPixelExecutableTask> pixelTask, + std::shared_ptr<ProgramD3D::GetGeometryExecutableTask> geometryTask, + bool useGS, + const ShaderD3D *vertexShader, + const ShaderD3D *fragmentShader) + : mInfoLog(infoLog), + mVertexTask(vertexTask), + mPixelTask(pixelTask), + mGeometryTask(geometryTask), + mWaitEvents({{std::shared_ptr<WaitableEvent>( + angle::WorkerThreadPool::PostWorkerTask(workerPool, mVertexTask)), + std::shared_ptr<WaitableEvent>( + angle::WorkerThreadPool::PostWorkerTask(workerPool, mPixelTask)), + std::shared_ptr<WaitableEvent>( + angle::WorkerThreadPool::PostWorkerTask(workerPool, mGeometryTask))}}), + mUseGS(useGS), + mVertexShader(vertexShader), + mFragmentShader(fragmentShader) + {} + + angle::Result wait(const gl::Context *context) override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GraphicsProgramLinkEvent::wait"); + WaitableEvent::WaitMany(&mWaitEvents); + + ANGLE_TRY(checkTask(context, mVertexTask.get())); + ANGLE_TRY(checkTask(context, mPixelTask.get())); + ANGLE_TRY(checkTask(context, mGeometryTask.get())); + + if (mVertexTask->getResult() == angle::Result::Incomplete || + mPixelTask->getResult() == angle::Result::Incomplete || + mGeometryTask->getResult() == angle::Result::Incomplete) + { + return angle::Result::Incomplete; + } + + ShaderExecutableD3D *defaultVertexExecutable = mVertexTask->getExecutable(); + ShaderExecutableD3D *defaultPixelExecutable = mPixelTask->getExecutable(); + ShaderExecutableD3D *pointGS = mGeometryTask->getExecutable(); + + if (mUseGS && pointGS) + { + // Geometry shaders are currently only used internally, so there is no corresponding + // shader object at the interface level. For now the geometry shader debug info is + // prepended to the vertex shader. + mVertexShader->appendDebugInfo("// GEOMETRY SHADER BEGIN\n\n"); + mVertexShader->appendDebugInfo(pointGS->getDebugInfo()); + mVertexShader->appendDebugInfo("\nGEOMETRY SHADER END\n\n\n"); + } + + if (defaultVertexExecutable) + { + mVertexShader->appendDebugInfo(defaultVertexExecutable->getDebugInfo()); + } + + if (defaultPixelExecutable) + { + mFragmentShader->appendDebugInfo(defaultPixelExecutable->getDebugInfo()); + } + + bool isLinked = (defaultVertexExecutable && defaultPixelExecutable && (!mUseGS || pointGS)); + if (!isLinked) + { + mInfoLog << "Failed to create D3D Shaders"; + } + return isLinked ? angle::Result::Continue : angle::Result::Incomplete; + } + + bool isLinking() override + { + for (auto &event : mWaitEvents) + { + if (!event->isReady()) + { + return true; + } + } + return false; + } + + private: + angle::Result checkTask(const gl::Context *context, ProgramD3D::GetExecutableTask *task) + { + if (!task->getInfoLog().empty()) + { + mInfoLog << task->getInfoLog().str(); + } + + // Continue and Incomplete are not errors. For Stop, pass the error to the ContextD3D. + if (task->getResult() != angle::Result::Stop) + { + return angle::Result::Continue; + } + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + task->popError(contextD3D); + return angle::Result::Stop; + } + + gl::InfoLog &mInfoLog; + std::shared_ptr<ProgramD3D::GetVertexExecutableTask> mVertexTask; + std::shared_ptr<ProgramD3D::GetPixelExecutableTask> mPixelTask; + std::shared_ptr<ProgramD3D::GetGeometryExecutableTask> mGeometryTask; + std::array<std::shared_ptr<WaitableEvent>, 3> mWaitEvents; + bool mUseGS; + const ShaderD3D *mVertexShader; + const ShaderD3D *mFragmentShader; +}; + +// The LinkEvent implementation for linking a computing program. +class ProgramD3D::ComputeProgramLinkEvent final : public LinkEvent +{ + public: + ComputeProgramLinkEvent(gl::InfoLog &infoLog, + std::shared_ptr<ProgramD3D::GetComputeExecutableTask> computeTask, + std::shared_ptr<WaitableEvent> event) + : mInfoLog(infoLog), mComputeTask(computeTask), mWaitEvent(event) + {} + + bool isLinking() override { return !mWaitEvent->isReady(); } + + angle::Result wait(const gl::Context *context) override + { + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::ComputeProgramLinkEvent::wait"); + mWaitEvent->wait(); + + angle::Result result = mComputeTask->getResult(); + if (result != angle::Result::Continue) + { + mInfoLog << "Failed to create D3D compute shader."; + } + return result; + } + + private: + gl::InfoLog &mInfoLog; + std::shared_ptr<ProgramD3D::GetComputeExecutableTask> mComputeTask; + std::shared_ptr<WaitableEvent> mWaitEvent; +}; + +std::unique_ptr<LinkEvent> ProgramD3D::compileProgramExecutables(const gl::Context *context, + gl::InfoLog &infoLog) +{ + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileProgramExecutables"); + // Ensure the compiler is initialized to avoid race conditions. + angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context)); + if (result != angle::Result::Continue) + { + return std::make_unique<LinkEventDone>(result); + } + + auto vertexTask = std::make_shared<GetVertexExecutableTask>(context, this); + auto pixelTask = std::make_shared<GetPixelExecutableTask>(context, this); + auto geometryTask = + std::make_shared<GetGeometryExecutableTask>(context, this, context->getState()); + bool useGS = usesGeometryShader(context->getState(), gl::PrimitiveMode::Points); + gl::Shader *vertexShader = mState.getAttachedShader(gl::ShaderType::Vertex); + gl::Shader *fragmentShader = mState.getAttachedShader(gl::ShaderType::Fragment); + const ShaderD3D *vertexShaderD3D = vertexShader ? GetImplAs<ShaderD3D>(vertexShader) : nullptr; + const ShaderD3D *fragmentShaderD3D = + fragmentShader ? GetImplAs<ShaderD3D>(fragmentShader) : nullptr; + + return std::make_unique<GraphicsProgramLinkEvent>(infoLog, context->getWorkerThreadPool(), + vertexTask, pixelTask, geometryTask, useGS, + vertexShaderD3D, fragmentShaderD3D); +} + +std::unique_ptr<LinkEvent> ProgramD3D::compileComputeExecutable(const gl::Context *context, + gl::InfoLog &infoLog) +{ + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileComputeExecutable"); + // Ensure the compiler is initialized to avoid race conditions. + angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context)); + if (result != angle::Result::Continue) + { + return std::make_unique<LinkEventDone>(result); + } + auto computeTask = std::make_shared<GetComputeExecutableTask>(context, this); + + std::shared_ptr<WaitableEvent> waitableEvent; + + // TODO(jie.a.chen@intel.com): Fix the flaky bug. + // http://anglebug.com/3349 + bool compileInParallel = false; + if (!compileInParallel) + { + (*computeTask)(); + waitableEvent = std::make_shared<WaitableEventDone>(); + } + else + { + waitableEvent = + WorkerThreadPool::PostWorkerTask(context->getWorkerThreadPool(), computeTask); + } + + return std::make_unique<ComputeProgramLinkEvent>(infoLog, computeTask, waitableEvent); +} + +angle::Result ProgramD3D::getComputeExecutableForImage2DBindLayout( + const gl::Context *glContext, + d3d::Context *context, + ShaderExecutableD3D **outExecutable, + gl::InfoLog *infoLog) +{ + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::getComputeExecutableForImage2DBindLayout"); + if (mCachedComputeExecutableIndex.valid()) + { + *outExecutable = + mComputeExecutables[mCachedComputeExecutableIndex.value()]->shaderExecutable(); + return angle::Result::Continue; + } + + std::string computeHLSL = + mState.getAttachedShader(gl::ShaderType::Compute)->getTranslatedSource(glContext); + + std::string finalComputeHLSL = mDynamicHLSL->generateShaderForImage2DBindSignature( + *this, mState, gl::ShaderType::Compute, computeHLSL, + mImage2DUniforms[gl::ShaderType::Compute], mImage2DBindLayoutCache[gl::ShaderType::Compute], + 0u); + + // Generate new compute executable + ShaderExecutableD3D *computeExecutable = nullptr; + + gl::InfoLog tempInfoLog; + gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog; + + ANGLE_TRY(mRenderer->compileToExecutable(context, *currentInfoLog, finalComputeHLSL, + gl::ShaderType::Compute, std::vector<D3DVarying>(), + false, CompilerWorkaroundsD3D(), &computeExecutable)); + + if (computeExecutable) + { + mComputeExecutables.push_back(std::unique_ptr<ComputeExecutable>( + new ComputeExecutable(mImage2DBindLayoutCache[gl::ShaderType::Compute], + std::unique_ptr<ShaderExecutableD3D>(computeExecutable)))); + mCachedComputeExecutableIndex = mComputeExecutables.size() - 1; + } + else if (!infoLog) + { + ERR() << "Error compiling dynamic compute executable:" << std::endl + << tempInfoLog.str() << std::endl; + } + *outExecutable = computeExecutable; + + return angle::Result::Continue; +} + +std::unique_ptr<LinkEvent> ProgramD3D::link(const gl::Context *context, + const gl::ProgramLinkedResources &resources, + gl::InfoLog &infoLog, + const gl::ProgramMergedVaryings & /*mergedVaryings*/) +{ + ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::link"); + const auto &data = context->getState(); + + reset(); + + gl::Shader *computeShader = mState.getAttachedShader(gl::ShaderType::Compute); + if (computeShader) + { + mShaderSamplers[gl::ShaderType::Compute].resize( + data.getCaps().maxShaderTextureImageUnits[gl::ShaderType::Compute]); + mImages[gl::ShaderType::Compute].resize(data.getCaps().maxImageUnits); + mReadonlyImages[gl::ShaderType::Compute].resize(data.getCaps().maxImageUnits); + + mShaderUniformsDirty.set(gl::ShaderType::Compute); + + linkResources(context, resources); + + for (const sh::ShaderVariable &uniform : computeShader->getUniforms(context)) + { + if (gl::IsImageType(uniform.type) && gl::IsImage2DType(uniform.type)) + { + mImage2DUniforms[gl::ShaderType::Compute].push_back(uniform); + } + } + + defineUniformsAndAssignRegisters(context); + + return compileComputeExecutable(context, infoLog); + } + else + { + gl::ShaderMap<const ShaderD3D *> shadersD3D = {}; + for (gl::ShaderType shaderType : gl::kAllGraphicsShaderTypes) + { + if (gl::Shader *shader = mState.getAttachedShader(shaderType)) + { + shadersD3D[shaderType] = GetImplAs<ShaderD3D>(mState.getAttachedShader(shaderType)); + + mShaderSamplers[shaderType].resize( + data.getCaps().maxShaderTextureImageUnits[shaderType]); + mImages[shaderType].resize(data.getCaps().maxImageUnits); + mReadonlyImages[shaderType].resize(data.getCaps().maxImageUnits); + + shadersD3D[shaderType]->generateWorkarounds(&mShaderWorkarounds[shaderType]); + + mShaderUniformsDirty.set(shaderType); + + const std::set<std::string> &slowCompilingUniformBlockSet = + shadersD3D[shaderType]->getSlowCompilingUniformBlockSet(); + if (slowCompilingUniformBlockSet.size() > 0) + { + std::ostringstream stream; + stream << "You could get a better shader compiling performance if you re-write" + << " the uniform block(s)\n[ "; + for (const std::string &str : slowCompilingUniformBlockSet) + { + stream << str << " "; + } + stream << "]\nin the " << gl::GetShaderTypeString(shaderType) << " shader.\n"; + + stream << "You could get more details from " + "https://chromium.googlesource.com/angle/angle/+/refs/heads/main/" + "src/libANGLE/renderer/d3d/d3d11/" + "UniformBlockToStructuredBufferTranslation.md\n"; + ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_MEDIUM, + stream.str().c_str()); + } + + for (const sh::ShaderVariable &uniform : shader->getUniforms(context)) + { + if (gl::IsImageType(uniform.type) && gl::IsImage2DType(uniform.type)) + { + mImage2DUniforms[shaderType].push_back(uniform); + } + } + } + } + + if (mRenderer->getNativeLimitations().noFrontFacingSupport) + { + const ShaderD3D *fragmentShader = shadersD3D[gl::ShaderType::Fragment]; + if (fragmentShader && fragmentShader->usesFrontFacing()) + { + infoLog << "The current renderer doesn't support gl_FrontFacing"; + return std::make_unique<LinkEventDone>(angle::Result::Incomplete); + } + } + + const gl::VaryingPacking &varyingPacking = + resources.varyingPacking.getOutputPacking(gl::ShaderType::Vertex); + + ProgramD3DMetadata metadata(mRenderer, shadersD3D, context->getClientType()); + BuiltinVaryingsD3D builtins(metadata, varyingPacking); + + mDynamicHLSL->generateShaderLinkHLSL(context, context->getCaps(), mState, metadata, + varyingPacking, builtins, &mShaderHLSL); + + const ShaderD3D *vertexShader = shadersD3D[gl::ShaderType::Vertex]; + mUsesPointSize = vertexShader && vertexShader->usesPointSize(); + mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey); + mUsesFragDepth = metadata.usesFragDepth(); + mUsesVertexID = metadata.usesVertexID(); + mUsesViewID = metadata.usesViewID(); + mHasANGLEMultiviewEnabled = metadata.hasANGLEMultiviewEnabled(); + + // Cache if we use flat shading + mUsesFlatInterpolation = FindFlatInterpolationVarying(context, mState.getAttachedShaders()); + + if (mRenderer->getMajorShaderModel() >= 4) + { + mGeometryShaderPreamble = mDynamicHLSL->generateGeometryShaderPreamble( + varyingPacking, builtins, mHasANGLEMultiviewEnabled, + metadata.canSelectViewInVertexShader()); + } + + initAttribLocationsToD3DSemantic(context); + + defineUniformsAndAssignRegisters(context); + + gatherTransformFeedbackVaryings(varyingPacking, builtins[gl::ShaderType::Vertex]); + + linkResources(context, resources); + + if (mState.getAttachedShader(gl::ShaderType::Vertex)) + { + updateCachedInputLayoutFromShader(context); + } + + return compileProgramExecutables(context, infoLog); + } +} + +GLboolean ProgramD3D::validate(const gl::Caps & /*caps*/, gl::InfoLog * /*infoLog*/) +{ + // TODO(jmadill): Do something useful here? + return GL_TRUE; +} + +void ProgramD3D::initializeShaderStorageBlocks(const gl::Context *context) +{ + if (mState.getShaderStorageBlocks().empty()) + { + return; + } + + ASSERT(mD3DShaderStorageBlocks.empty()); + + // Assign registers and update sizes. + gl::ShaderMap<const ShaderD3D *> shadersD3D = {}; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + shadersD3D[shaderType] = SafeGetImplAs<ShaderD3D>(mState.getAttachedShader(shaderType)); + } + for (const gl::InterfaceBlock &shaderStorageBlock : mState.getShaderStorageBlocks()) + { + unsigned int shaderStorageBlockElement = + shaderStorageBlock.isArray ? shaderStorageBlock.arrayElement : 0; + D3DInterfaceBlock d3dShaderStorageBlock; + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (shaderStorageBlock.isActive(shaderType)) + { + ASSERT(shadersD3D[shaderType]); + unsigned int baseRegister = + shadersD3D[shaderType]->getShaderStorageBlockRegister(shaderStorageBlock.name); + + d3dShaderStorageBlock.mShaderRegisterIndexes[shaderType] = + baseRegister + shaderStorageBlockElement; + } + } + mD3DShaderStorageBlocks.push_back(d3dShaderStorageBlock); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + gl::Shader *shader = mState.getAttachedShader(shaderType); + if (!shader) + { + continue; + } + ShaderD3D *shaderD3D = SafeGetImplAs<ShaderD3D>(shader); + for (const sh::InterfaceBlock &ssbo : shader->getShaderStorageBlocks(context)) + { + if (!ssbo.active) + { + continue; + } + ShaderStorageBlock block; + block.name = !ssbo.instanceName.empty() ? ssbo.instanceName : ssbo.name; + block.arraySize = ssbo.isArray() ? ssbo.arraySize : 0; + block.registerIndex = shaderD3D->getShaderStorageBlockRegister(ssbo.name); + mShaderStorageBlocks[shaderType].push_back(block); + } + } +} + +void ProgramD3D::initializeUniformBlocks() +{ + if (mState.getUniformBlocks().empty()) + { + return; + } + + ASSERT(mD3DUniformBlocks.empty()); + + // Assign registers and update sizes. + gl::ShaderMap<const ShaderD3D *> shadersD3D = {}; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + shadersD3D[shaderType] = SafeGetImplAs<ShaderD3D>(mState.getAttachedShader(shaderType)); + } + + for (const gl::InterfaceBlock &uniformBlock : mState.getUniformBlocks()) + { + unsigned int uniformBlockElement = uniformBlock.isArray ? uniformBlock.arrayElement : 0; + + D3DUniformBlock d3dUniformBlock; + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (uniformBlock.isActive(shaderType)) + { + ASSERT(shadersD3D[shaderType]); + unsigned int baseRegister = + shadersD3D[shaderType]->getUniformBlockRegister(uniformBlock.name); + d3dUniformBlock.mShaderRegisterIndexes[shaderType] = + baseRegister + uniformBlockElement; + bool useStructuredBuffer = + shadersD3D[shaderType]->shouldUniformBlockUseStructuredBuffer( + uniformBlock.name); + if (useStructuredBuffer) + { + d3dUniformBlock.mUseStructuredBuffers[shaderType] = true; + d3dUniformBlock.mByteWidths[shaderType] = uniformBlock.dataSize; + d3dUniformBlock.mStructureByteStrides[shaderType] = + uniformBlock.firstFieldArraySize == 0u + ? uniformBlock.dataSize + : uniformBlock.dataSize / uniformBlock.firstFieldArraySize; + } + } + } + + mD3DUniformBlocks.push_back(d3dUniformBlock); + } +} + +void ProgramD3D::initializeUniformStorage(const gl::ShaderBitSet &availableShaderStages) +{ + // Compute total default block size + gl::ShaderMap<unsigned int> shaderRegisters = {}; + for (const D3DUniform *d3dUniform : mD3DUniforms) + { + if (d3dUniform->isSampler()) + { + continue; + } + + for (gl::ShaderType shaderType : availableShaderStages) + { + if (d3dUniform->isReferencedByShader(shaderType)) + { + shaderRegisters[shaderType] = std::max( + shaderRegisters[shaderType], + d3dUniform->mShaderRegisterIndexes[shaderType] + d3dUniform->registerCount); + } + } + } + + // We only reset uniform storages for the shader stages available in the program (attached + // shaders in ProgramD3D::link() and linkedShaderStages in ProgramD3D::load()). + for (gl::ShaderType shaderType : availableShaderStages) + { + mShaderUniformStorages[shaderType].reset( + mRenderer->createUniformStorage(shaderRegisters[shaderType] * 16u)); + } + + // Iterate the uniforms again to assign data pointers to default block uniforms. + for (D3DUniform *d3dUniform : mD3DUniforms) + { + if (d3dUniform->isSampler()) + { + d3dUniform->mSamplerData.resize(d3dUniform->getArraySizeProduct(), 0); + continue; + } + + for (gl::ShaderType shaderType : availableShaderStages) + { + if (d3dUniform->isReferencedByShader(shaderType)) + { + d3dUniform->mShaderData[shaderType] = + mShaderUniformStorages[shaderType]->getDataPointer( + d3dUniform->mShaderRegisterIndexes[shaderType], + d3dUniform->registerElement); + } + } + } +} + +void ProgramD3D::updateUniformBufferCache(const gl::Caps &caps) +{ + if (mState.getUniformBlocks().empty()) + { + return; + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + mShaderUBOCaches[shaderType].clear(); + mShaderUBOCachesUseSB[shaderType].clear(); + } + + for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < mD3DUniformBlocks.size(); + uniformBlockIndex++) + { + const D3DUniformBlock &uniformBlock = mD3DUniformBlocks[uniformBlockIndex]; + GLuint blockBinding = mState.getUniformBlockBinding(uniformBlockIndex); + + // Unnecessary to apply an unreferenced standard or shared UBO + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (!uniformBlock.activeInShader(shaderType)) + { + continue; + } + + bool useStructuredBuffer = uniformBlock.mUseStructuredBuffers[shaderType]; + unsigned int registerIndex = uniformBlock.mShaderRegisterIndexes[shaderType]; + if (useStructuredBuffer) + { + D3DUBOCacheUseSB cacheUseSB; + cacheUseSB.registerIndex = registerIndex; + cacheUseSB.binding = blockBinding; + cacheUseSB.byteWidth = uniformBlock.mByteWidths[shaderType]; + cacheUseSB.structureByteStride = uniformBlock.mStructureByteStrides[shaderType]; + mShaderUBOCachesUseSB[shaderType].push_back(cacheUseSB); + } + else + { + ASSERT(registerIndex < + static_cast<unsigned int>(caps.maxShaderUniformBlocks[shaderType])); + D3DUBOCache cache; + cache.registerIndex = registerIndex; + cache.binding = blockBinding; + mShaderUBOCaches[shaderType].push_back(cache); + } + } + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + GLuint uniformBlockCount = static_cast<GLuint>(mShaderUBOCaches[shaderType].size() + + mShaderUBOCachesUseSB[shaderType].size()); + ASSERT(uniformBlockCount <= + static_cast<unsigned int>(caps.maxShaderUniformBlocks[shaderType])); + } +} + +unsigned int ProgramD3D::getAtomicCounterBufferRegisterIndex(GLuint binding, + gl::ShaderType shaderType) const +{ + if (shaderType != gl::ShaderType::Compute) + { + // Implement atomic counters for non-compute shaders + // http://anglebug.com/1729 + UNIMPLEMENTED(); + } + return mComputeAtomicCounterBufferRegisterIndices[binding]; +} + +unsigned int ProgramD3D::getShaderStorageBufferRegisterIndex(GLuint blockIndex, + gl::ShaderType shaderType) const +{ + return mD3DShaderStorageBlocks[blockIndex].mShaderRegisterIndexes[shaderType]; +} + +const std::vector<D3DUBOCache> &ProgramD3D::getShaderUniformBufferCache( + gl::ShaderType shaderType) const +{ + return mShaderUBOCaches[shaderType]; +} + +const std::vector<D3DUBOCacheUseSB> &ProgramD3D::getShaderUniformBufferCacheUseSB( + gl::ShaderType shaderType) const +{ + return mShaderUBOCachesUseSB[shaderType]; +} + +void ProgramD3D::dirtyAllUniforms() +{ + mShaderUniformsDirty = mState.getExecutable().getLinkedShaderStages(); +} + +void ProgramD3D::markUniformsClean() +{ + mShaderUniformsDirty.reset(); +} + +void ProgramD3D::setUniform1fv(GLint location, GLsizei count, const GLfloat *v) +{ + setUniformInternal(location, count, v, GL_FLOAT); +} + +void ProgramD3D::setUniform2fv(GLint location, GLsizei count, const GLfloat *v) +{ + setUniformInternal(location, count, v, GL_FLOAT_VEC2); +} + +void ProgramD3D::setUniform3fv(GLint location, GLsizei count, const GLfloat *v) +{ + setUniformInternal(location, count, v, GL_FLOAT_VEC3); +} + +void ProgramD3D::setUniform4fv(GLint location, GLsizei count, const GLfloat *v) +{ + setUniformInternal(location, count, v, GL_FLOAT_VEC4); +} + +void ProgramD3D::setUniformMatrix2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<2, 2>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<3, 3>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<4, 4>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix2x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<2, 3>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix3x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<3, 2>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix2x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<2, 4>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix4x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<4, 2>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix3x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<3, 4>(location, count, transpose, value); +} + +void ProgramD3D::setUniformMatrix4x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + setUniformMatrixfvInternal<4, 3>(location, count, transpose, value); +} + +void ProgramD3D::setUniform1iv(GLint location, GLsizei count, const GLint *v) +{ + setUniformInternal(location, count, v, GL_INT); +} + +void ProgramD3D::setUniform2iv(GLint location, GLsizei count, const GLint *v) +{ + setUniformInternal(location, count, v, GL_INT_VEC2); +} + +void ProgramD3D::setUniform3iv(GLint location, GLsizei count, const GLint *v) +{ + setUniformInternal(location, count, v, GL_INT_VEC3); +} + +void ProgramD3D::setUniform4iv(GLint location, GLsizei count, const GLint *v) +{ + setUniformInternal(location, count, v, GL_INT_VEC4); +} + +void ProgramD3D::setUniform1uiv(GLint location, GLsizei count, const GLuint *v) +{ + setUniformInternal(location, count, v, GL_UNSIGNED_INT); +} + +void ProgramD3D::setUniform2uiv(GLint location, GLsizei count, const GLuint *v) +{ + setUniformInternal(location, count, v, GL_UNSIGNED_INT_VEC2); +} + +void ProgramD3D::setUniform3uiv(GLint location, GLsizei count, const GLuint *v) +{ + setUniformInternal(location, count, v, GL_UNSIGNED_INT_VEC3); +} + +void ProgramD3D::setUniform4uiv(GLint location, GLsizei count, const GLuint *v) +{ + setUniformInternal(location, count, v, GL_UNSIGNED_INT_VEC4); +} + +void ProgramD3D::defineUniformsAndAssignRegisters(const gl::Context *context) +{ + D3DUniformMap uniformMap; + + gl::ShaderBitSet attachedShaders; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + gl::Shader *shader = mState.getAttachedShader(shaderType); + if (shader) + { + for (const sh::ShaderVariable &uniform : shader->getUniforms(context)) + { + if (uniform.active) + { + defineUniformBase(shader, uniform, &uniformMap); + } + } + + attachedShaders.set(shader->getType()); + } + } + + // Initialize the D3DUniform list to mirror the indexing of the GL layer. + for (const gl::LinkedUniform &glUniform : mState.getUniforms()) + { + if (!glUniform.isInDefaultBlock()) + continue; + + std::string name = glUniform.name; + if (glUniform.isArray()) + { + // In the program state, array uniform names include [0] as in the program resource + // spec. Here we don't include it. + // TODO(oetuaho@nvidia.com): consider using the same uniform naming here as in the GL + // layer. + ASSERT(angle::EndsWith(name, "[0]")); + name.resize(name.length() - 3); + } + auto mapEntry = uniformMap.find(name); + ASSERT(mapEntry != uniformMap.end()); + mD3DUniforms.push_back(mapEntry->second); + } + + assignAllSamplerRegisters(); + assignAllAtomicCounterRegisters(); + // Samplers and readonly images share shader input resource slot, adjust low value of + // readonly image range. + for (gl::ShaderType shaderType : {gl::ShaderType::Compute, gl::ShaderType::Fragment}) + { + mUsedReadonlyImageRange[shaderType] = + gl::RangeUI(mUsedShaderSamplerRanges[shaderType].high(), + mUsedShaderSamplerRanges[shaderType].high()); + // Atomic counter buffers and non-readonly images share input resource slots + mUsedImageRange[shaderType] = gl::RangeUI(mUsedAtomicCounterRange[shaderType].high(), + mUsedAtomicCounterRange[shaderType].high()); + } + assignAllImageRegisters(); + initializeUniformStorage(attachedShaders); +} + +void ProgramD3D::defineUniformBase(const gl::Shader *shader, + const sh::ShaderVariable &uniform, + D3DUniformMap *uniformMap) +{ + sh::StubBlockEncoder stubEncoder; + + // Samplers get their registers assigned in assignAllSamplerRegisters, and images get their + // registers assigned in assignAllImageRegisters. + if (gl::IsSamplerType(uniform.type)) + { + UniformEncodingVisitorD3D visitor(shader->getType(), HLSLRegisterType::Texture, + &stubEncoder, uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); + return; + } + + if (gl::IsImageType(uniform.type)) + { + if (uniform.readonly) + { + UniformEncodingVisitorD3D visitor(shader->getType(), HLSLRegisterType::Texture, + &stubEncoder, uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); + } + else + { + UniformEncodingVisitorD3D visitor( + shader->getType(), HLSLRegisterType::UnorderedAccessView, &stubEncoder, uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); + } + mImageBindingMap[uniform.name] = uniform.binding; + return; + } + + if (uniform.isBuiltIn() && !uniform.isEmulatedBuiltIn()) + { + UniformEncodingVisitorD3D visitor(shader->getType(), HLSLRegisterType::None, &stubEncoder, + uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); + return; + } + else if (gl::IsAtomicCounterType(uniform.type)) + { + UniformEncodingVisitorD3D visitor(shader->getType(), HLSLRegisterType::UnorderedAccessView, + &stubEncoder, uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); + mAtomicBindingMap[uniform.name] = uniform.binding; + return; + } + + const ShaderD3D *shaderD3D = GetImplAs<ShaderD3D>(shader); + unsigned int startRegister = shaderD3D->getUniformRegister(uniform.name); + ShShaderOutput outputType = shaderD3D->getCompilerOutputType(); + sh::HLSLBlockEncoder encoder(sh::HLSLBlockEncoder::GetStrategyFor(outputType), true); + encoder.skipRegisters(startRegister); + + UniformEncodingVisitorD3D visitor(shader->getType(), HLSLRegisterType::None, &encoder, + uniformMap); + sh::TraverseShaderVariable(uniform, false, &visitor); +} + +bool ProgramD3D::hasNamedUniform(const std::string &name) +{ + for (D3DUniform *d3dUniform : mD3DUniforms) + { + if (d3dUniform->name == name) + { + return true; + } + } + + return false; +} + +// Assume count is already clamped. +template <typename T> +void ProgramD3D::setUniformImpl(D3DUniform *targetUniform, + const gl::VariableLocation &locationInfo, + GLsizei count, + const T *v, + uint8_t *targetState, + GLenum uniformType) +{ + const int components = targetUniform->typeInfo.componentCount; + const unsigned int arrayElementOffset = locationInfo.arrayIndex; + const int blockSize = 4; + + if (targetUniform->typeInfo.type == uniformType) + { + T *dest = reinterpret_cast<T *>(targetState) + arrayElementOffset * blockSize; + const T *source = v; + + // If the component is equal to the block size, we can optimize to a single memcpy. + // Otherwise, we have to do partial block writes. + if (components == blockSize) + { + memcpy(dest, source, components * count * sizeof(T)); + } + else + { + for (GLint i = 0; i < count; i++, dest += blockSize, source += components) + { + memcpy(dest, source, components * sizeof(T)); + } + } + } + else + { + ASSERT(targetUniform->typeInfo.type == gl::VariableBoolVectorType(uniformType)); + GLint *boolParams = reinterpret_cast<GLint *>(targetState) + arrayElementOffset * 4; + + for (GLint i = 0; i < count; i++) + { + GLint *dest = boolParams + (i * 4); + const T *source = v + (i * components); + + for (int c = 0; c < components; c++) + { + dest[c] = (source[c] == static_cast<T>(0)) ? GL_FALSE : GL_TRUE; + } + } + } +} + +template <typename T> +void ProgramD3D::setUniformInternal(GLint location, GLsizei count, const T *v, GLenum uniformType) +{ + const gl::VariableLocation &locationInfo = mState.getUniformLocations()[location]; + D3DUniform *targetUniform = mD3DUniforms[locationInfo.index]; + + if (targetUniform->typeInfo.isSampler) + { + ASSERT(uniformType == GL_INT); + size_t size = count * sizeof(T); + GLint *dest = &targetUniform->mSamplerData[locationInfo.arrayIndex]; + if (memcmp(dest, v, size) != 0) + { + memcpy(dest, v, size); + mDirtySamplerMapping = true; + } + return; + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + uint8_t *targetState = targetUniform->mShaderData[shaderType]; + if (targetState) + { + setUniformImpl(targetUniform, locationInfo, count, v, targetState, uniformType); + mShaderUniformsDirty.set(shaderType); + } + } +} + +template <int cols, int rows> +void ProgramD3D::setUniformMatrixfvInternal(GLint location, + GLsizei countIn, + GLboolean transpose, + const GLfloat *value) +{ + D3DUniform *targetUniform = getD3DUniformFromLocation(location); + const gl::VariableLocation &uniformLocation = mState.getUniformLocations()[location]; + unsigned int arrayElementOffset = uniformLocation.arrayIndex; + unsigned int elementCount = targetUniform->getArraySizeProduct(); + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (targetUniform->mShaderData[shaderType]) + { + SetFloatUniformMatrixHLSL<cols, rows>::Run(arrayElementOffset, elementCount, countIn, + transpose, value, + targetUniform->mShaderData[shaderType]); + mShaderUniformsDirty.set(shaderType); + } + } +} + +void ProgramD3D::assignAllSamplerRegisters() +{ + for (size_t uniformIndex = 0; uniformIndex < mD3DUniforms.size(); ++uniformIndex) + { + if (mD3DUniforms[uniformIndex]->isSampler()) + { + assignSamplerRegisters(uniformIndex); + } + } +} + +void ProgramD3D::assignSamplerRegisters(size_t uniformIndex) +{ + D3DUniform *d3dUniform = mD3DUniforms[uniformIndex]; + ASSERT(d3dUniform->isSampler()); + // If the uniform is an array of arrays, then we have separate entries for each inner array in + // mD3DUniforms. However, the sampler register info is stored in the shader only for the + // outermost array. + std::vector<unsigned int> subscripts; + const std::string baseName = gl::ParseResourceName(d3dUniform->name, &subscripts); + unsigned int registerOffset = + mState.getUniforms()[uniformIndex].parentArrayIndex() * d3dUniform->getArraySizeProduct(); + + bool hasUniform = false; + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + if (!mState.getAttachedShader(shaderType)) + { + continue; + } + + const ShaderD3D *shaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedShader(shaderType)); + if (shaderD3D->hasUniform(baseName)) + { + d3dUniform->mShaderRegisterIndexes[shaderType] = + shaderD3D->getUniformRegister(baseName) + registerOffset; + ASSERT(d3dUniform->mShaderRegisterIndexes[shaderType] != GL_INVALID_VALUE); + + AssignSamplers(d3dUniform->mShaderRegisterIndexes[shaderType], d3dUniform->typeInfo, + d3dUniform->getArraySizeProduct(), mShaderSamplers[shaderType], + &mUsedShaderSamplerRanges[shaderType]); + hasUniform = true; + } + } + + ASSERT(hasUniform); +} + +// static +void ProgramD3D::AssignSamplers(unsigned int startSamplerIndex, + const gl::UniformTypeInfo &typeInfo, + unsigned int samplerCount, + std::vector<Sampler> &outSamplers, + gl::RangeUI *outUsedRange) +{ + unsigned int samplerIndex = startSamplerIndex; + + do + { + ASSERT(samplerIndex < outSamplers.size()); + Sampler *sampler = &outSamplers[samplerIndex]; + sampler->active = true; + sampler->textureType = gl::FromGLenum<gl::TextureType>(typeInfo.textureType); + sampler->logicalTextureUnit = 0; + outUsedRange->extend(samplerIndex); + samplerIndex++; + } while (samplerIndex < startSamplerIndex + samplerCount); +} + +void ProgramD3D::assignAllImageRegisters() +{ + for (size_t uniformIndex = 0; uniformIndex < mD3DUniforms.size(); ++uniformIndex) + { + if (mD3DUniforms[uniformIndex]->isImage() && !mD3DUniforms[uniformIndex]->isImage2D()) + { + assignImageRegisters(uniformIndex); + } + } +} + +void ProgramD3D::assignAllAtomicCounterRegisters() +{ + if (mAtomicBindingMap.empty()) + { + return; + } + gl::ShaderType shaderType = gl::ShaderType::Compute; + const gl::Shader *computeShader = mState.getAttachedShader(shaderType); + if (computeShader) + { + const ShaderD3D *computeShaderD3D = GetImplAs<ShaderD3D>(computeShader); + auto ®isterIndices = mComputeAtomicCounterBufferRegisterIndices; + for (auto &atomicBinding : mAtomicBindingMap) + { + ASSERT(computeShaderD3D->hasUniform(atomicBinding.first)); + unsigned int currentRegister = + computeShaderD3D->getUniformRegister(atomicBinding.first); + ASSERT(currentRegister != GL_INVALID_INDEX); + const int kBinding = atomicBinding.second; + + registerIndices[kBinding] = currentRegister; + + mUsedAtomicCounterRange[gl::ShaderType::Compute].extend(currentRegister); + } + } + else + { + // Implement atomic counters for non-compute shaders + // http://anglebug.com/1729 + UNIMPLEMENTED(); + } +} + +void ProgramD3D::assignImageRegisters(size_t uniformIndex) +{ + D3DUniform *d3dUniform = mD3DUniforms[uniformIndex]; + ASSERT(d3dUniform->isImage()); + // If the uniform is an array of arrays, then we have separate entries for each inner array in + // mD3DUniforms. However, the image register info is stored in the shader only for the + // outermost array. + std::vector<unsigned int> subscripts; + const std::string baseName = gl::ParseResourceName(d3dUniform->name, &subscripts); + unsigned int registerOffset = + mState.getUniforms()[uniformIndex].parentArrayIndex() * d3dUniform->getArraySizeProduct(); + + const gl::Shader *computeShader = mState.getAttachedShader(gl::ShaderType::Compute); + if (computeShader) + { + const ShaderD3D *computeShaderD3D = + GetImplAs<ShaderD3D>(mState.getAttachedShader(gl::ShaderType::Compute)); + ASSERT(computeShaderD3D->hasUniform(baseName)); + d3dUniform->mShaderRegisterIndexes[gl::ShaderType::Compute] = + computeShaderD3D->getUniformRegister(baseName) + registerOffset; + ASSERT(d3dUniform->mShaderRegisterIndexes[gl::ShaderType::Compute] != GL_INVALID_INDEX); + auto bindingIter = mImageBindingMap.find(baseName); + ASSERT(bindingIter != mImageBindingMap.end()); + if (d3dUniform->regType == HLSLRegisterType::Texture) + { + AssignImages(d3dUniform->mShaderRegisterIndexes[gl::ShaderType::Compute], + bindingIter->second, d3dUniform->getArraySizeProduct(), + mReadonlyImages[gl::ShaderType::Compute], + &mUsedReadonlyImageRange[gl::ShaderType::Compute]); + } + else if (d3dUniform->regType == HLSLRegisterType::UnorderedAccessView) + { + AssignImages(d3dUniform->mShaderRegisterIndexes[gl::ShaderType::Compute], + bindingIter->second, d3dUniform->getArraySizeProduct(), + mImages[gl::ShaderType::Compute], + &mUsedImageRange[gl::ShaderType::Compute]); + } + else + { + UNREACHABLE(); + } + } + else + { + // TODO(xinghua.cao@intel.com): Implement image variables in vertex shader and pixel shader. + UNIMPLEMENTED(); + } +} + +// static +void ProgramD3D::AssignImages(unsigned int startImageIndex, + int startLogicalImageUnit, + unsigned int imageCount, + std::vector<Image> &outImages, + gl::RangeUI *outUsedRange) +{ + unsigned int imageIndex = startImageIndex; + + // If declare without a binding qualifier, any uniform image variable (include all elements of + // unbound image array) shoud be bound to unit zero. + if (startLogicalImageUnit == -1) + { + ASSERT(imageIndex < outImages.size()); + Image *image = &outImages[imageIndex]; + image->active = true; + image->logicalImageUnit = 0; + outUsedRange->extend(imageIndex); + return; + } + + unsigned int logcalImageUnit = startLogicalImageUnit; + do + { + ASSERT(imageIndex < outImages.size()); + Image *image = &outImages[imageIndex]; + image->active = true; + image->logicalImageUnit = logcalImageUnit; + outUsedRange->extend(imageIndex); + imageIndex++; + logcalImageUnit++; + } while (imageIndex < startImageIndex + imageCount); +} + +void ProgramD3D::assignImage2DRegisters(gl::ShaderType shaderType, + unsigned int startImageIndex, + int startLogicalImageUnit, + bool readonly) +{ + if (readonly) + { + AssignImages(startImageIndex, startLogicalImageUnit, 1, mReadonlyImages[shaderType], + &mUsedReadonlyImageRange[shaderType]); + } + else + { + AssignImages(startImageIndex, startLogicalImageUnit, 1, mImages[shaderType], + &mUsedImageRange[shaderType]); + } +} + +void ProgramD3D::reset() +{ + mVertexExecutables.clear(); + mPixelExecutables.clear(); + mComputeExecutables.clear(); + + for (auto &geometryExecutable : mGeometryExecutables) + { + geometryExecutable.reset(nullptr); + } + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + mShaderHLSL[shaderType].clear(); + } + + mUsesFragDepth = false; + mHasANGLEMultiviewEnabled = false; + mUsesVertexID = false; + mUsesViewID = false; + mPixelShaderKey.clear(); + mUsesPointSize = false; + mUsesFlatInterpolation = false; + + SafeDeleteContainer(mD3DUniforms); + mD3DUniformBlocks.clear(); + mD3DShaderStorageBlocks.clear(); + mComputeAtomicCounterBufferRegisterIndices.fill({}); + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + mShaderUniformStorages[shaderType].reset(); + mShaderSamplers[shaderType].clear(); + mImages[shaderType].clear(); + mReadonlyImages[shaderType].clear(); + } + + mUsedShaderSamplerRanges.fill({0, 0}); + mUsedAtomicCounterRange.fill({0, 0}); + mDirtySamplerMapping = true; + mUsedImageRange.fill({0, 0}); + mUsedReadonlyImageRange.fill({0, 0}); + + mAttribLocationToD3DSemantic.fill(-1); + + mStreamOutVaryings.clear(); + + mGeometryShaderPreamble.clear(); + + markUniformsClean(); + + mCachedPixelExecutableIndex.reset(); + mCachedVertexExecutableIndex.reset(); +} + +unsigned int ProgramD3D::getSerial() const +{ + return mSerial; +} + +unsigned int ProgramD3D::issueSerial() +{ + return mCurrentSerial++; +} + +void ProgramD3D::initAttribLocationsToD3DSemantic(const gl::Context *context) +{ + gl::Shader *vertexShader = mState.getAttachedShader(gl::ShaderType::Vertex); + if (!vertexShader) + { + return; + } + + // Init semantic index + int semanticIndex = 0; + for (const sh::ShaderVariable &attribute : vertexShader->getActiveAttributes(context)) + { + int regCount = gl::VariableRegisterCount(attribute.type); + GLuint location = mState.getAttributeLocation(attribute.name); + ASSERT(location != std::numeric_limits<GLuint>::max()); + + for (int reg = 0; reg < regCount; ++reg) + { + mAttribLocationToD3DSemantic[location + reg] = semanticIndex++; + } + } +} + +void ProgramD3D::updateCachedInputLayout(Serial associatedSerial, const gl::State &state) +{ + if (mCurrentVertexArrayStateSerial == associatedSerial) + { + return; + } + + mCurrentVertexArrayStateSerial = associatedSerial; + mCachedInputLayout.clear(); + + const auto &vertexAttributes = state.getVertexArray()->getVertexAttributes(); + const gl::AttributesMask &attributesMask = + mState.getExecutable().getActiveAttribLocationsMask(); + + for (size_t locationIndex : attributesMask) + { + int d3dSemantic = mAttribLocationToD3DSemantic[locationIndex]; + + if (d3dSemantic != -1) + { + if (mCachedInputLayout.size() < static_cast<size_t>(d3dSemantic + 1)) + { + mCachedInputLayout.resize(d3dSemantic + 1, angle::FormatID::NONE); + } + mCachedInputLayout[d3dSemantic] = + GetVertexFormatID(vertexAttributes[locationIndex], + state.getVertexAttribCurrentValue(locationIndex).Type); + } + } + + VertexExecutable::getSignature(mRenderer, mCachedInputLayout, &mCachedVertexSignature); + + updateCachedVertexExecutableIndex(); +} + +void ProgramD3D::updateCachedOutputLayout(const gl::Context *context, + const gl::Framebuffer *framebuffer) +{ + mPixelShaderOutputLayoutCache.clear(); + + FramebufferD3D *fboD3D = GetImplAs<FramebufferD3D>(framebuffer); + const auto &colorbuffers = fboD3D->getColorAttachmentsForRender(context); + + for (size_t colorAttachment = 0; colorAttachment < colorbuffers.size(); ++colorAttachment) + { + const gl::FramebufferAttachment *colorbuffer = colorbuffers[colorAttachment]; + + if (colorbuffer) + { + auto binding = colorbuffer->getBinding() == GL_BACK ? GL_COLOR_ATTACHMENT0 + : colorbuffer->getBinding(); + size_t maxIndex = binding != GL_NONE ? GetMaxOutputIndex(mPixelShaderKey, + binding - GL_COLOR_ATTACHMENT0) + : 0; + mPixelShaderOutputLayoutCache.insert(mPixelShaderOutputLayoutCache.end(), maxIndex + 1, + binding); + } + else + { + mPixelShaderOutputLayoutCache.push_back(GL_NONE); + } + } + + updateCachedPixelExecutableIndex(); +} + +void ProgramD3D::updateCachedComputeImage2DBindLayout(const gl::Context *context) +{ + const auto &glState = context->getState(); + for (auto &image2DBindLayout : mImage2DBindLayoutCache[gl::ShaderType::Compute]) + { + const gl::ImageUnit &imageUnit = glState.getImageUnit(image2DBindLayout.first); + if (imageUnit.texture.get()) + { + image2DBindLayout.second = imageUnit.texture->getType(); + } + else + { + image2DBindLayout.second = gl::TextureType::_2D; + } + } + + updateCachedComputeExecutableIndex(); +} + +void ProgramD3D::gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyingPacking, + const BuiltinInfo &builtins) +{ + const std::string &varyingSemantic = + GetVaryingSemantic(mRenderer->getMajorShaderModel(), usesPointSize()); + + // Gather the linked varyings that are used for transform feedback, they should all exist. + mStreamOutVaryings.clear(); + + const auto &tfVaryingNames = mState.getTransformFeedbackVaryingNames(); + for (unsigned int outputSlot = 0; outputSlot < static_cast<unsigned int>(tfVaryingNames.size()); + ++outputSlot) + { + const auto &tfVaryingName = tfVaryingNames[outputSlot]; + if (tfVaryingName == "gl_Position") + { + if (builtins.glPosition.enabled) + { + mStreamOutVaryings.emplace_back(builtins.glPosition.semantic, + builtins.glPosition.index, 4, outputSlot); + } + } + else if (tfVaryingName == "gl_FragCoord") + { + if (builtins.glFragCoord.enabled) + { + mStreamOutVaryings.emplace_back(builtins.glFragCoord.semantic, + builtins.glFragCoord.index, 4, outputSlot); + } + } + else if (tfVaryingName == "gl_PointSize") + { + if (builtins.glPointSize.enabled) + { + mStreamOutVaryings.emplace_back("PSIZE", 0, 1, outputSlot); + } + } + else + { + const auto ®isterInfos = varyingPacking.getRegisterList(); + for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex) + { + const auto ®isterInfo = registerInfos[registerIndex]; + const auto &varying = registerInfo.packedVarying->varying(); + GLenum transposedType = gl::TransposeMatrixType(varying.type); + int componentCount = gl::VariableColumnCount(transposedType); + ASSERT(!varying.isBuiltIn() && !varying.isStruct()); + + // There can be more than one register assigned to a particular varying, and each + // register needs its own stream out entry. + if (registerInfo.tfVaryingName() == tfVaryingName) + { + mStreamOutVaryings.emplace_back(varyingSemantic, registerIndex, componentCount, + outputSlot); + } + } + } + } +} + +D3DUniform *ProgramD3D::getD3DUniformFromLocation(GLint location) +{ + return mD3DUniforms[mState.getUniformLocations()[location].index]; +} + +const D3DUniform *ProgramD3D::getD3DUniformFromLocation(GLint location) const +{ + return mD3DUniforms[mState.getUniformLocations()[location].index]; +} + +bool ProgramD3D::hasVertexExecutableForCachedInputLayout() +{ + return mCachedVertexExecutableIndex.valid(); +} + +bool ProgramD3D::hasGeometryExecutableForPrimitiveType(const gl::State &state, + gl::PrimitiveMode drawMode) +{ + if (!usesGeometryShader(state, drawMode)) + { + // No shader necessary mean we have the required (null) executable. + return true; + } + + gl::PrimitiveMode geometryShaderType = GetGeometryShaderTypeFromDrawMode(drawMode); + return mGeometryExecutables[geometryShaderType].get() != nullptr; +} + +bool ProgramD3D::hasPixelExecutableForCachedOutputLayout() +{ + return mCachedPixelExecutableIndex.valid(); +} + +bool ProgramD3D::hasComputeExecutableForCachedImage2DBindLayout() +{ + return mCachedComputeExecutableIndex.valid(); +} + +template <typename DestT> +void ProgramD3D::getUniformInternal(GLint location, DestT *dataOut) const +{ + const gl::VariableLocation &locationInfo = mState.getUniformLocations()[location]; + const gl::LinkedUniform &uniform = mState.getUniforms()[locationInfo.index]; + + const D3DUniform *targetUniform = getD3DUniformFromLocation(location); + const uint8_t *srcPointer = targetUniform->getDataPtrToElement(locationInfo.arrayIndex); + + if (gl::IsMatrixType(uniform.type)) + { + GetMatrixUniform(uniform.type, dataOut, reinterpret_cast<const DestT *>(srcPointer), true); + } + else + { + memcpy(dataOut, srcPointer, uniform.getElementSize()); + } +} + +void ProgramD3D::getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const +{ + getUniformInternal(location, params); +} + +void ProgramD3D::getUniformiv(const gl::Context *context, GLint location, GLint *params) const +{ + getUniformInternal(location, params); +} + +void ProgramD3D::getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const +{ + getUniformInternal(location, params); +} + +void ProgramD3D::updateCachedVertexExecutableIndex() +{ + mCachedVertexExecutableIndex.reset(); + for (size_t executableIndex = 0; executableIndex < mVertexExecutables.size(); executableIndex++) + { + if (mVertexExecutables[executableIndex]->matchesSignature(mCachedVertexSignature)) + { + mCachedVertexExecutableIndex = executableIndex; + break; + } + } +} + +void ProgramD3D::updateCachedPixelExecutableIndex() +{ + mCachedPixelExecutableIndex.reset(); + for (size_t executableIndex = 0; executableIndex < mPixelExecutables.size(); executableIndex++) + { + if (mPixelExecutables[executableIndex]->matchesSignature(mPixelShaderOutputLayoutCache)) + { + mCachedPixelExecutableIndex = executableIndex; + break; + } + } +} + +void ProgramD3D::updateCachedComputeExecutableIndex() +{ + mCachedComputeExecutableIndex.reset(); + for (size_t executableIndex = 0; executableIndex < mComputeExecutables.size(); + executableIndex++) + { + if (mComputeExecutables[executableIndex]->matchesSignature( + mImage2DBindLayoutCache[gl::ShaderType::Compute])) + { + mCachedComputeExecutableIndex = executableIndex; + break; + } + } +} + +void ProgramD3D::linkResources(const gl::Context *context, + const gl::ProgramLinkedResources &resources) +{ + HLSLBlockLayoutEncoderFactory hlslEncoderFactory; + gl::ProgramLinkedResourcesLinker linker(&hlslEncoderFactory); + + linker.linkResources(context, mState, resources); + + initializeUniformBlocks(); + initializeShaderStorageBlocks(context); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.h new file mode 100644 index 0000000000..baa77fcb79 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ProgramD3D.h @@ -0,0 +1,613 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ProgramD3D.h: Defines the rx::ProgramD3D class which implements rx::ProgramImpl. + +#ifndef LIBANGLE_RENDERER_D3D_PROGRAMD3D_H_ +#define LIBANGLE_RENDERER_D3D_PROGRAMD3D_H_ + +#include <string> +#include <vector> + +#include "compiler/translator/blocklayoutHLSL.h" +#include "libANGLE/Constants.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/ProgramImpl.h" +#include "libANGLE/renderer/d3d/DynamicHLSL.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "platform/FeaturesD3D_autogen.h" + +namespace rx +{ +class RendererD3D; +class UniformStorageD3D; +class ShaderExecutableD3D; + +#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL) +// WARNING: D3DCOMPILE_OPTIMIZATION_LEVEL3 may lead to a DX9 shader compiler hang. +// It should only be used selectively to work around specific bugs. +# define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL1 +#endif + +enum class HLSLRegisterType : uint8_t +{ + None = 0, + Texture = 1, + UnorderedAccessView = 2 +}; + +// Helper struct representing a single shader uniform +// TODO(jmadill): Make uniform blocks shared between all programs, so we don't need separate +// register indices. +struct D3DUniform : private angle::NonCopyable +{ + D3DUniform(GLenum type, + HLSLRegisterType reg, + const std::string &nameIn, + const std::vector<unsigned int> &arraySizesIn, + bool defaultBlock); + ~D3DUniform(); + + bool isSampler() const; + bool isImage() const; + bool isImage2D() const; + bool isArray() const { return !arraySizes.empty(); } + unsigned int getArraySizeProduct() const; + bool isReferencedByShader(gl::ShaderType shaderType) const; + + const uint8_t *firstNonNullData() const; + const uint8_t *getDataPtrToElement(size_t elementIndex) const; + + // Duplicated from the GL layer + const gl::UniformTypeInfo &typeInfo; + std::string name; // Names of arrays don't include [0], unlike at the GL layer. + std::vector<unsigned int> arraySizes; + + // Pointer to a system copies of the data. Separate pointers for each uniform storage type. + gl::ShaderMap<uint8_t *> mShaderData; + + // Register information. + HLSLRegisterType regType; + gl::ShaderMap<unsigned int> mShaderRegisterIndexes; + unsigned int registerCount; + + // Register "elements" are used for uniform structs in ES3, to appropriately identify single + // uniforms + // inside aggregate types, which are packed according C-like structure rules. + unsigned int registerElement; + + // Special buffer for sampler values. + std::vector<GLint> mSamplerData; +}; + +struct D3DInterfaceBlock +{ + D3DInterfaceBlock(); + D3DInterfaceBlock(const D3DInterfaceBlock &other); + + bool activeInShader(gl::ShaderType shaderType) const + { + return mShaderRegisterIndexes[shaderType] != GL_INVALID_INDEX; + } + + gl::ShaderMap<unsigned int> mShaderRegisterIndexes; +}; + +struct D3DUniformBlock : D3DInterfaceBlock +{ + D3DUniformBlock(); + D3DUniformBlock(const D3DUniformBlock &other); + + gl::ShaderMap<bool> mUseStructuredBuffers; + gl::ShaderMap<unsigned int> mByteWidths; + gl::ShaderMap<unsigned int> mStructureByteStrides; +}; + +struct ShaderStorageBlock +{ + std::string name; + unsigned int arraySize = 0; + unsigned int registerIndex = 0; +}; + +struct D3DUBOCache +{ + unsigned int registerIndex; + int binding; +}; + +struct D3DUBOCacheUseSB : D3DUBOCache +{ + unsigned int byteWidth; + unsigned int structureByteStride; +}; + +struct D3DVarying final +{ + D3DVarying(); + D3DVarying(const std::string &semanticNameIn, + unsigned int semanticIndexIn, + unsigned int componentCountIn, + unsigned int outputSlotIn); + + D3DVarying(const D3DVarying &) = default; + D3DVarying &operator=(const D3DVarying &) = default; + + std::string semanticName; + unsigned int semanticIndex; + unsigned int componentCount; + unsigned int outputSlot; +}; + +class ProgramD3DMetadata final : angle::NonCopyable +{ + public: + ProgramD3DMetadata(RendererD3D *renderer, + const gl::ShaderMap<const ShaderD3D *> &attachedShaders, + EGLenum clientType); + ~ProgramD3DMetadata(); + + int getRendererMajorShaderModel() const; + bool usesBroadcast(const gl::State &data) const; + bool usesSecondaryColor() const; + bool usesFragDepth() const; + bool usesPointCoord() const; + bool usesFragCoord() const; + bool usesPointSize() const; + bool usesInsertedPointCoordValue() const; + bool usesViewScale() const; + bool hasANGLEMultiviewEnabled() const; + bool usesVertexID() const; + bool usesViewID() const; + bool canSelectViewInVertexShader() const; + bool addsPointCoordToVertexShader() const; + bool usesTransformFeedbackGLPosition() const; + bool usesSystemValuePointSize() const; + bool usesMultipleFragmentOuts() const; + bool usesCustomOutVars() const; + const ShaderD3D *getFragmentShader() const; + + private: + const int mRendererMajorShaderModel; + const std::string mShaderModelSuffix; + const bool mUsesInstancedPointSpriteEmulation; + const bool mUsesViewScale; + const bool mCanSelectViewInVertexShader; + const gl::ShaderMap<const ShaderD3D *> mAttachedShaders; + const EGLenum mClientType; +}; + +using D3DUniformMap = std::map<std::string, D3DUniform *>; + +class ProgramD3D : public ProgramImpl +{ + public: + ProgramD3D(const gl::ProgramState &data, RendererD3D *renderer); + ~ProgramD3D() override; + + const std::vector<PixelShaderOutputVariable> &getPixelShaderKey() { return mPixelShaderKey; } + + GLint getSamplerMapping(gl::ShaderType type, + unsigned int samplerIndex, + const gl::Caps &caps) const; + gl::TextureType getSamplerTextureType(gl::ShaderType type, unsigned int samplerIndex) const; + gl::RangeUI getUsedSamplerRange(gl::ShaderType type) const; + + enum SamplerMapping + { + WasDirty, + WasClean, + }; + + SamplerMapping updateSamplerMapping(); + + GLint getImageMapping(gl::ShaderType type, + unsigned int imageIndex, + bool readonly, + const gl::Caps &caps) const; + gl::RangeUI getUsedImageRange(gl::ShaderType type, bool readonly) const; + + bool usesPointSize() const { return mUsesPointSize; } + bool usesPointSpriteEmulation() const; + bool usesGeometryShader(const gl::State &state, gl::PrimitiveMode drawMode) const; + bool usesGeometryShaderForPointSpriteEmulation() const; + bool usesGetDimensionsIgnoresBaseLevel() const; + bool usesInstancedPointSpriteEmulation() const; + + std::unique_ptr<LinkEvent> load(const gl::Context *context, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog) override; + void save(const gl::Context *context, gl::BinaryOutputStream *stream) override; + void setBinaryRetrievableHint(bool retrievable) override; + void setSeparable(bool separable) override; + + angle::Result getVertexExecutableForCachedInputLayout(d3d::Context *context, + ShaderExecutableD3D **outExectuable, + gl::InfoLog *infoLog); + angle::Result getGeometryExecutableForPrimitiveType(d3d::Context *errContext, + const gl::State &state, + gl::PrimitiveMode drawMode, + ShaderExecutableD3D **outExecutable, + gl::InfoLog *infoLog); + angle::Result getPixelExecutableForCachedOutputLayout(d3d::Context *context, + ShaderExecutableD3D **outExectuable, + gl::InfoLog *infoLog); + angle::Result getComputeExecutableForImage2DBindLayout(const gl::Context *glContext, + d3d::Context *context, + ShaderExecutableD3D **outExecutable, + gl::InfoLog *infoLog); + std::unique_ptr<LinkEvent> link(const gl::Context *context, + const gl::ProgramLinkedResources &resources, + gl::InfoLog &infoLog, + const gl::ProgramMergedVaryings &mergedVaryings) override; + GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) override; + + void updateUniformBufferCache(const gl::Caps &caps); + + unsigned int getAtomicCounterBufferRegisterIndex(GLuint binding, + gl::ShaderType shaderType) const; + + unsigned int getShaderStorageBufferRegisterIndex(GLuint blockIndex, + gl::ShaderType shaderType) const; + const std::vector<D3DUBOCache> &getShaderUniformBufferCache(gl::ShaderType shaderType) const; + const std::vector<D3DUBOCacheUseSB> &getShaderUniformBufferCacheUseSB( + gl::ShaderType shaderType) const; + + void dirtyAllUniforms(); + + void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) override; + void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) override; + void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) override; + void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) override; + void setUniform1iv(GLint location, GLsizei count, const GLint *v) override; + void setUniform2iv(GLint location, GLsizei count, const GLint *v) override; + void setUniform3iv(GLint location, GLsizei count, const GLint *v) override; + void setUniform4iv(GLint location, GLsizei count, const GLint *v) override; + void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) override; + void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) override; + void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) override; + void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) override; + void setUniformMatrix2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix2x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix3x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix2x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix4x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix3x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + void setUniformMatrix4x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) override; + + void getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const override; + void getUniformiv(const gl::Context *context, GLint location, GLint *params) const override; + void getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const override; + + UniformStorageD3D *getShaderUniformStorage(gl::ShaderType shaderType) const + { + return mShaderUniformStorages[shaderType].get(); + } + + unsigned int getSerial() const; + + const AttribIndexArray &getAttribLocationToD3DSemantics() const + { + return mAttribLocationToD3DSemantic; + } + + void updateCachedInputLayout(Serial associatedSerial, const gl::State &state); + void updateCachedOutputLayout(const gl::Context *context, const gl::Framebuffer *framebuffer); + void updateCachedComputeImage2DBindLayout(const gl::Context *context); + + bool isSamplerMappingDirty() { return mDirtySamplerMapping; } + + // Checks if we need to recompile certain shaders. + bool hasVertexExecutableForCachedInputLayout(); + bool hasGeometryExecutableForPrimitiveType(const gl::State &state, gl::PrimitiveMode drawMode); + bool hasPixelExecutableForCachedOutputLayout(); + bool hasComputeExecutableForCachedImage2DBindLayout(); + + bool anyShaderUniformsDirty() const { return mShaderUniformsDirty.any(); } + + bool areShaderUniformsDirty(gl::ShaderType shaderType) const + { + return mShaderUniformsDirty[shaderType]; + } + const std::vector<D3DUniform *> &getD3DUniforms() const { return mD3DUniforms; } + void markUniformsClean(); + + const gl::ProgramState &getState() const { return mState; } + + bool hasShaderStage(gl::ShaderType shaderType) const + { + return mState.getExecutable().getLinkedShaderStages()[shaderType]; + } + + void assignImage2DRegisters(gl::ShaderType shaderType, + unsigned int startImageIndex, + int startLogicalImageUnit, + bool readonly); + bool hasNamedUniform(const std::string &name); + + bool usesVertexID() const { return mUsesVertexID; } + + private: + // These forward-declared tasks are used for multi-thread shader compiles. + class GetExecutableTask; + class GetVertexExecutableTask; + class GetPixelExecutableTask; + class GetGeometryExecutableTask; + class GetComputeExecutableTask; + class GraphicsProgramLinkEvent; + class ComputeProgramLinkEvent; + + class LoadBinaryTask; + class LoadBinaryLinkEvent; + + class VertexExecutable + { + public: + enum HLSLAttribType + { + FLOAT, + UNSIGNED_INT, + SIGNED_INT, + }; + + typedef std::vector<HLSLAttribType> Signature; + + VertexExecutable(const gl::InputLayout &inputLayout, + const Signature &signature, + ShaderExecutableD3D *shaderExecutable); + ~VertexExecutable(); + + bool matchesSignature(const Signature &signature) const; + static void getSignature(RendererD3D *renderer, + const gl::InputLayout &inputLayout, + Signature *signatureOut); + + const gl::InputLayout &inputs() const { return mInputs; } + const Signature &signature() const { return mSignature; } + ShaderExecutableD3D *shaderExecutable() const { return mShaderExecutable; } + + private: + static HLSLAttribType GetAttribType(GLenum type); + + gl::InputLayout mInputs; + Signature mSignature; + ShaderExecutableD3D *mShaderExecutable; + }; + + class PixelExecutable + { + public: + PixelExecutable(const std::vector<GLenum> &outputSignature, + ShaderExecutableD3D *shaderExecutable); + ~PixelExecutable(); + + bool matchesSignature(const std::vector<GLenum> &signature) const + { + return mOutputSignature == signature; + } + + const std::vector<GLenum> &outputSignature() const { return mOutputSignature; } + ShaderExecutableD3D *shaderExecutable() const { return mShaderExecutable; } + + private: + std::vector<GLenum> mOutputSignature; + ShaderExecutableD3D *mShaderExecutable; + }; + + class ComputeExecutable + { + public: + ComputeExecutable(const gl::ImageUnitTextureTypeMap &signature, + std::unique_ptr<ShaderExecutableD3D> shaderExecutable); + ~ComputeExecutable(); + + bool matchesSignature(const gl::ImageUnitTextureTypeMap &signature) const + { + return mSignature == signature; + } + + const gl::ImageUnitTextureTypeMap &signature() const { return mSignature; } + ShaderExecutableD3D *shaderExecutable() const { return mShaderExecutable.get(); } + + private: + gl::ImageUnitTextureTypeMap mSignature; + std::unique_ptr<ShaderExecutableD3D> mShaderExecutable; + }; + + struct Sampler + { + Sampler(); + + bool active; + GLint logicalTextureUnit; + gl::TextureType textureType; + }; + + struct Image + { + Image(); + bool active; + GLint logicalImageUnit; + }; + + void initializeUniformStorage(const gl::ShaderBitSet &availableShaderStages); + + void defineUniformsAndAssignRegisters(const gl::Context *context); + void defineUniformBase(const gl::Shader *shader, + const sh::ShaderVariable &uniform, + D3DUniformMap *uniformMap); + void assignAllSamplerRegisters(); + void assignSamplerRegisters(size_t uniformIndex); + + static void AssignSamplers(unsigned int startSamplerIndex, + const gl::UniformTypeInfo &typeInfo, + unsigned int samplerCount, + std::vector<Sampler> &outSamplers, + gl::RangeUI *outUsedRange); + + void assignAllImageRegisters(); + void assignAllAtomicCounterRegisters(); + void assignImageRegisters(size_t uniformIndex); + static void AssignImages(unsigned int startImageIndex, + int startLogicalImageUnit, + unsigned int imageCount, + std::vector<Image> &outImages, + gl::RangeUI *outUsedRange); + + template <typename DestT> + void getUniformInternal(GLint location, DestT *dataOut) const; + + template <typename T> + void setUniformImpl(D3DUniform *targetUniform, + const gl::VariableLocation &locationInfo, + GLsizei count, + const T *v, + uint8_t *targetData, + GLenum uniformType); + + template <typename T> + void setUniformInternal(GLint location, GLsizei count, const T *v, GLenum uniformType); + + template <int cols, int rows> + void setUniformMatrixfvInternal(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); + + std::unique_ptr<LinkEvent> compileProgramExecutables(const gl::Context *context, + gl::InfoLog &infoLog); + std::unique_ptr<LinkEvent> compileComputeExecutable(const gl::Context *context, + gl::InfoLog &infoLog); + + angle::Result loadBinaryShaderExecutables(d3d::Context *contextD3D, + gl::BinaryInputStream *stream, + gl::InfoLog &infoLog); + + void gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyings, + const BuiltinInfo &builtins); + D3DUniform *getD3DUniformFromLocation(GLint location); + const D3DUniform *getD3DUniformFromLocation(GLint location) const; + + void initAttribLocationsToD3DSemantic(const gl::Context *context); + + void reset(); + void initializeUniformBlocks(); + void initializeShaderStorageBlocks(const gl::Context *context); + + void updateCachedInputLayoutFromShader(const gl::Context *context); + void updateCachedOutputLayoutFromShader(); + void updateCachedImage2DBindLayoutFromShader(gl::ShaderType shaderType); + void updateCachedVertexExecutableIndex(); + void updateCachedPixelExecutableIndex(); + void updateCachedComputeExecutableIndex(); + + void linkResources(const gl::Context *context, const gl::ProgramLinkedResources &resources); + + RendererD3D *mRenderer; + DynamicHLSL *mDynamicHLSL; + + std::vector<std::unique_ptr<VertexExecutable>> mVertexExecutables; + std::vector<std::unique_ptr<PixelExecutable>> mPixelExecutables; + angle::PackedEnumMap<gl::PrimitiveMode, std::unique_ptr<ShaderExecutableD3D>> + mGeometryExecutables; + std::vector<std::unique_ptr<ComputeExecutable>> mComputeExecutables; + + gl::ShaderMap<std::string> mShaderHLSL; + gl::ShaderMap<CompilerWorkaroundsD3D> mShaderWorkarounds; + + bool mUsesFragDepth; + bool mHasANGLEMultiviewEnabled; + bool mUsesVertexID; + bool mUsesViewID; + std::vector<PixelShaderOutputVariable> mPixelShaderKey; + + // Common code for all dynamic geometry shaders. Consists mainly of the GS input and output + // structures, built from the linked varying info. We store the string itself instead of the + // packed varyings for simplicity. + std::string mGeometryShaderPreamble; + + bool mUsesPointSize; + bool mUsesFlatInterpolation; + + gl::ShaderMap<std::unique_ptr<UniformStorageD3D>> mShaderUniformStorages; + + gl::ShaderMap<std::vector<Sampler>> mShaderSamplers; + gl::ShaderMap<gl::RangeUI> mUsedShaderSamplerRanges; + bool mDirtySamplerMapping; + + gl::ShaderMap<std::vector<Image>> mImages; + gl::ShaderMap<std::vector<Image>> mReadonlyImages; + gl::ShaderMap<gl::RangeUI> mUsedImageRange; + gl::ShaderMap<gl::RangeUI> mUsedReadonlyImageRange; + gl::ShaderMap<gl::RangeUI> mUsedAtomicCounterRange; + + // Cache for pixel shader output layout to save reallocations. + std::vector<GLenum> mPixelShaderOutputLayoutCache; + Optional<size_t> mCachedPixelExecutableIndex; + + AttribIndexArray mAttribLocationToD3DSemantic; + + unsigned int mSerial; + + gl::ShaderMap<std::vector<D3DUBOCache>> mShaderUBOCaches; + gl::ShaderMap<std::vector<D3DUBOCacheUseSB>> mShaderUBOCachesUseSB; + VertexExecutable::Signature mCachedVertexSignature; + gl::InputLayout mCachedInputLayout; + Optional<size_t> mCachedVertexExecutableIndex; + + std::vector<D3DVarying> mStreamOutVaryings; + std::vector<D3DUniform *> mD3DUniforms; + std::map<std::string, int> mImageBindingMap; + std::map<std::string, int> mAtomicBindingMap; + std::vector<D3DUniformBlock> mD3DUniformBlocks; + std::vector<D3DInterfaceBlock> mD3DShaderStorageBlocks; + gl::ShaderMap<std::vector<ShaderStorageBlock>> mShaderStorageBlocks; + std::array<unsigned int, gl::IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS> + mComputeAtomicCounterBufferRegisterIndices; + + gl::ShaderMap<std::vector<sh::ShaderVariable>> mImage2DUniforms; + gl::ShaderMap<gl::ImageUnitTextureTypeMap> mImage2DBindLayoutCache; + Optional<size_t> mCachedComputeExecutableIndex; + + gl::ShaderBitSet mShaderUniformsDirty; + + static unsigned int issueSerial(); + static unsigned int mCurrentSerial; + + Serial mCurrentVertexArrayStateSerial; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_PROGRAMD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.cpp new file mode 100644 index 0000000000..4529a9d84e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.cpp @@ -0,0 +1,31 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTargetD3D.cpp: Implements serial handling for rx::RenderTargetD3D + +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" + +namespace rx +{ +unsigned int RenderTargetD3D::mCurrentSerial = 1; + +RenderTargetD3D::RenderTargetD3D() : mSerial(issueSerials(1)) {} + +RenderTargetD3D::~RenderTargetD3D() {} + +unsigned int RenderTargetD3D::getSerial() const +{ + return mSerial; +} + +unsigned int RenderTargetD3D::issueSerials(unsigned int count) +{ + unsigned int firstSerial = mCurrentSerial; + mCurrentSerial += count; + return firstSerial; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.h new file mode 100644 index 0000000000..b5bed63bcd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderTargetD3D.h @@ -0,0 +1,44 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTargetD3D.h: Defines an abstract wrapper class to manage IDirect3DSurface9 +// and ID3D11View objects belonging to renderbuffers and renderable textures. + +#ifndef LIBANGLE_RENDERER_D3D_RENDERTARGETD3D_H_ +#define LIBANGLE_RENDERER_D3D_RENDERTARGETD3D_H_ + +#include "common/angleutils.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/angletypes.h" + +namespace rx +{ + +class RenderTargetD3D : public FramebufferAttachmentRenderTarget +{ + public: + RenderTargetD3D(); + ~RenderTargetD3D() override; + + virtual GLsizei getWidth() const = 0; + virtual GLsizei getHeight() const = 0; + virtual GLsizei getDepth() const = 0; + virtual GLenum getInternalFormat() const = 0; + virtual GLsizei getSamples() const = 0; + gl::Extents getExtents() const { return gl::Extents(getWidth(), getHeight(), getDepth()); } + bool isMultisampled() const { return getSamples() > 0; } + + virtual unsigned int getSerial() const; + static unsigned int issueSerials(unsigned int count); + + private: + const unsigned int mSerial; + static unsigned int mCurrentSerial; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_RENDERTARGETD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp new file mode 100644 index 0000000000..9114b88f3f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp @@ -0,0 +1,126 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderbufferD3d.cpp: Implements the RenderbufferD3D class, a specialization of RenderbufferImpl + +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" + +#include "libANGLE/Context.h" +#include "libANGLE/Image.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/EGLImageD3D.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ +RenderbufferD3D::RenderbufferD3D(const gl::RenderbufferState &state, RendererD3D *renderer) + : RenderbufferImpl(state), mRenderer(renderer), mRenderTarget(nullptr), mImage(nullptr) +{} + +RenderbufferD3D::~RenderbufferD3D() +{ + SafeDelete(mRenderTarget); + mImage = nullptr; +} + +void RenderbufferD3D::onDestroy(const gl::Context *context) +{ + SafeDelete(mRenderTarget); +} + +angle::Result RenderbufferD3D::setStorage(const gl::Context *context, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return setStorageMultisample(context, 0, internalformat, width, height, + gl::MultisamplingMode::Regular); +} + +angle::Result RenderbufferD3D::setStorageMultisample(const gl::Context *context, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + gl::MultisamplingMode mode) +{ + // TODO: Correctly differentiate between normal multisampling and render to texture. In the + // latter case, the renderbuffer must be automatically resolved when rendering is broken and + // operations performed on it (such as blit, copy etc) should use the resolved image. + // http://anglebug.com/3107. + + // If the renderbuffer parameters are queried, the calling function + // will expect one of the valid renderbuffer formats for use in + // glRenderbufferStorage, but we should create depth and stencil buffers + // as DEPTH24_STENCIL8 + GLenum creationFormat = internalformat; + if (internalformat == GL_DEPTH_COMPONENT16 || internalformat == GL_STENCIL_INDEX8) + { + creationFormat = GL_DEPTH24_STENCIL8_OES; + } + + // ANGLE_framebuffer_multisample states GL_OUT_OF_MEMORY is generated on a failure to create + // the specified storage. + // Because ES 3.0 already knows the exact number of supported samples, it would already have + // been validated and generated GL_INVALID_VALUE. + const gl::TextureCaps &formatCaps = mRenderer->getNativeTextureCaps().get(creationFormat); + ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextD3D>(context), + static_cast<uint32_t>(samples) <= formatCaps.getMaxSamples()); + + RenderTargetD3D *newRT = nullptr; + ANGLE_TRY( + mRenderer->createRenderTarget(context, width, height, creationFormat, samples, &newRT)); + + SafeDelete(mRenderTarget); + mImage = nullptr; + mRenderTarget = newRT; + + return angle::Result::Continue; +} + +angle::Result RenderbufferD3D::setStorageEGLImageTarget(const gl::Context *context, + egl::Image *image) +{ + mImage = GetImplAs<EGLImageD3D>(image); + SafeDelete(mRenderTarget); + + return angle::Result::Continue; +} + +angle::Result RenderbufferD3D::getRenderTarget(const gl::Context *context, + RenderTargetD3D **outRenderTarget) +{ + if (mImage) + { + return mImage->getRenderTarget(context, outRenderTarget); + } + else + { + *outRenderTarget = mRenderTarget; + return angle::Result::Continue; + } +} + +angle::Result RenderbufferD3D::getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) +{ + return getRenderTarget(context, reinterpret_cast<RenderTargetD3D **>(rtOut)); +} + +angle::Result RenderbufferD3D::initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) +{ + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, &renderTarget)); + return mRenderer->initRenderTarget(context, renderTarget); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.h new file mode 100644 index 0000000000..7b48c48073 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RenderbufferD3D.h @@ -0,0 +1,63 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderbufferD3d.h: Defines the RenderbufferD3D class which implements RenderbufferImpl. + +#ifndef LIBANGLE_RENDERER_D3D_RENDERBUFFERD3D_H_ +#define LIBANGLE_RENDERER_D3D_RENDERBUFFERD3D_H_ + +#include "angle_gl.h" + +#include "common/angleutils.h" +#include "libANGLE/renderer/RenderbufferImpl.h" + +namespace rx +{ +class EGLImageD3D; +class RendererD3D; +class RenderTargetD3D; +class SwapChainD3D; + +class RenderbufferD3D : public RenderbufferImpl +{ + public: + RenderbufferD3D(const gl::RenderbufferState &state, RendererD3D *renderer); + ~RenderbufferD3D() override; + + void onDestroy(const gl::Context *context) override; + + angle::Result setStorage(const gl::Context *context, + GLenum internalformat, + GLsizei width, + GLsizei height) override; + angle::Result setStorageMultisample(const gl::Context *context, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + gl::MultisamplingMode mode) override; + angle::Result setStorageEGLImageTarget(const gl::Context *context, egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, RenderTargetD3D **outRenderTarget); + angle::Result getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) override; + + angle::Result initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) override; + + private: + RendererD3D *mRenderer; + RenderTargetD3D *mRenderTarget; + EGLImageD3D *mImage; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_RENDERBUFFERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.cpp new file mode 100644 index 0000000000..39e6e536dd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.cpp @@ -0,0 +1,247 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RendererD3D.cpp: Implementation of the base D3D Renderer. + +#include "libANGLE/renderer/d3d/RendererD3D.h" + +#include "common/MemoryBuffer.h" +#include "common/debug.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#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" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/TextureImpl.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/DeviceD3D.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#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 +{ + +RendererD3D::RendererD3D(egl::Display *display) + : mDisplay(display), + mPresentPathFastEnabled(false), + mCapsInitialized(false), + mFeaturesInitialized(false), + mDisjoint(false), + mDeviceLost(false) +{} + +RendererD3D::~RendererD3D() {} + +bool RendererD3D::skipDraw(const gl::State &glState, gl::PrimitiveMode drawMode) +{ + if (drawMode == gl::PrimitiveMode::Points) + { + bool usesPointSize = GetImplAs<ProgramD3D>(glState.getProgram())->usesPointSize(); + + // ProgramBinary assumes non-point rendering if gl_PointSize isn't written, + // which affects varying interpolation. Since the value of gl_PointSize is + // undefined when not written, just skip drawing to avoid unexpected results. + if (!usesPointSize && !glState.isTransformFeedbackActiveUnpaused()) + { + // Notify developers of risking undefined behavior. + WARN() << "Point rendering without writing to gl_PointSize."; + return true; + } + } + else if (gl::IsTriangleMode(drawMode)) + { + if (glState.getRasterizerState().cullFace && + glState.getRasterizerState().cullMode == gl::CullFaceMode::FrontAndBack) + { + return true; + } + } + + return false; +} + +gl::GraphicsResetStatus RendererD3D::getResetStatus() +{ + if (!mDeviceLost) + { + if (testDeviceLost()) + { + mDeviceLost = true; + notifyDeviceLost(); + return gl::GraphicsResetStatus::UnknownContextReset; + } + return gl::GraphicsResetStatus::NoError; + } + + if (testDeviceResettable()) + { + return gl::GraphicsResetStatus::NoError; + } + + return gl::GraphicsResetStatus::UnknownContextReset; +} + +void RendererD3D::notifyDeviceLost() +{ + mDisplay->notifyDeviceLost(); +} + +void RendererD3D::setGPUDisjoint() +{ + mDisjoint = true; +} + +GLint RendererD3D::getGPUDisjoint() +{ + bool disjoint = mDisjoint; + + // Disjoint flag is cleared when read + mDisjoint = false; + + return disjoint; +} + +GLint64 RendererD3D::getTimestamp() +{ + // D3D has no way to get an actual timestamp reliably so 0 is returned + return 0; +} + +void RendererD3D::ensureCapsInitialized() const +{ + if (!mCapsInitialized) + { + generateCaps(&mNativeCaps, &mNativeTextureCaps, &mNativeExtensions, &mNativeLimitations); + mCapsInitialized = true; + } +} + +const gl::Caps &RendererD3D::getNativeCaps() const +{ + ensureCapsInitialized(); + return mNativeCaps; +} + +const gl::TextureCapsMap &RendererD3D::getNativeTextureCaps() const +{ + ensureCapsInitialized(); + return mNativeTextureCaps; +} + +const gl::Extensions &RendererD3D::getNativeExtensions() const +{ + ensureCapsInitialized(); + return mNativeExtensions; +} + +const gl::Limitations &RendererD3D::getNativeLimitations() const +{ + ensureCapsInitialized(); + return mNativeLimitations; +} + +ShPixelLocalStorageType RendererD3D::getNativePixelLocalStorageType() const +{ + if (!getNativeExtensions().shaderPixelLocalStorageANGLE) + { + return ShPixelLocalStorageType::NotSupported; + } + // Read/write UAVs only support "r32*" images. + return ShPixelLocalStorageType::ImageStoreR32PackedFormats; +} + +Serial RendererD3D::generateSerial() +{ + return mSerialFactory.generate(); +} + +bool InstancedPointSpritesActive(ProgramD3D *programD3D, gl::PrimitiveMode mode) +{ + return programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation() && + mode == gl::PrimitiveMode::Points; +} + +angle::Result RendererD3D::initRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget) +{ + return clearRenderTarget(context, renderTarget, gl::ColorF(0, 0, 0, 0), 1, 0); +} + +const angle::FeaturesD3D &RendererD3D::getFeatures() const +{ + if (!mFeaturesInitialized) + { + initializeFeatures(&mFeatures); + mFeaturesInitialized = true; + } + + return mFeatures; +} + +unsigned int GetBlendSampleMask(const gl::State &glState, int samples) +{ + unsigned int mask = 0; + if (glState.isSampleCoverageEnabled()) + { + GLfloat coverageValue = glState.getSampleCoverageValue(); + if (coverageValue != 0) + { + float threshold = 0.5f; + + for (int i = 0; i < samples; ++i) + { + mask <<= 1; + + if ((i + 1) * coverageValue >= threshold) + { + threshold += 1.0f; + mask |= 1; + } + } + } + + bool coverageInvert = glState.getSampleCoverageInvert(); + if (coverageInvert) + { + mask = ~mask; + } + } + else + { + mask = 0xFFFFFFFF; + } + + if (glState.isSampleMaskEnabled()) + { + mask &= glState.getSampleMaskWord(0); + } + + return mask; +} + +GLenum DefaultGLErrorCode(HRESULT hr) +{ + switch (hr) + { +#ifdef ANGLE_ENABLE_D3D9 + case D3DERR_OUTOFVIDEOMEMORY: +#endif + case E_OUTOFMEMORY: + return GL_OUT_OF_MEMORY; + default: + return GL_INVALID_OPERATION; + } +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.h new file mode 100644 index 0000000000..3846e1eb2a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/RendererD3D.h @@ -0,0 +1,489 @@ + +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RendererD3D.h: Defines a back-end specific class for the DirectX renderer. + +#ifndef LIBANGLE_RENDERER_D3D_RENDERERD3D_H_ +#define LIBANGLE_RENDERER_D3D_RENDERERD3D_H_ + +#include <array> + +#include "common/Color.h" +#include "common/MemoryBuffer.h" +#include "common/debug.h" +#include "libANGLE/Device.h" +#include "libANGLE/State.h" +#include "libANGLE/Version.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" +#include "libANGLE/renderer/d3d/formatutilsD3D.h" +#include "libANGLE/renderer/renderer_utils.h" +#include "libANGLE/renderer/serial_utils.h" +#include "platform/FeaturesD3D_autogen.h" + +namespace egl +{ +class ConfigSet; +} + +namespace gl +{ +class ErrorSet; +class FramebufferState; +class InfoLog; +class Texture; +struct LinkedVarying; +} // namespace gl + +namespace rx +{ +class ContextImpl; +struct D3DUniform; +struct D3DVarying; +class DeviceD3D; +class EGLImageD3D; +class FramebufferImpl; +class ImageD3D; +class IndexBuffer; +class NativeWindowD3D; +class ProgramD3D; +class RenderTargetD3D; +class ShaderExecutableD3D; +class SwapChainD3D; +class TextureStorage; +struct TranslatedIndexData; +class UniformStorageD3D; +class VertexBuffer; + +struct DeviceIdentifier +{ + UINT VendorId; + UINT DeviceId; + UINT SubSysId; + UINT Revision; + UINT FeatureLevel; +}; + +enum RendererClass +{ + RENDERER_D3D11, + RENDERER_D3D9 +}; + +struct BindFlags +{ + bool renderTarget = false; + bool unorderedAccess = false; + static BindFlags RenderTarget() + { + BindFlags flags; + flags.renderTarget = true; + return flags; + } + static BindFlags UnorderedAccess() + { + BindFlags flags; + flags.unorderedAccess = true; + return flags; + } +}; + +// A d3d::Context wraps error handling. +namespace d3d +{ +class Context : angle::NonCopyable +{ + public: + Context() {} + virtual ~Context() {} + + virtual void handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) = 0; +}; +} // namespace d3d + +// ANGLE_TRY for HRESULT errors. +#define ANGLE_TRY_HR(CONTEXT, EXPR, MESSAGE) \ + do \ + { \ + auto ANGLE_LOCAL_VAR = (EXPR); \ + if (ANGLE_UNLIKELY(FAILED(ANGLE_LOCAL_VAR))) \ + { \ + CONTEXT->handleResult(ANGLE_LOCAL_VAR, MESSAGE, __FILE__, ANGLE_FUNCTION, __LINE__); \ + return angle::Result::Stop; \ + } \ + } while (0) + +#define ANGLE_CHECK_HR(CONTEXT, EXPR, MESSAGE, ERROR) \ + do \ + { \ + if (ANGLE_UNLIKELY(!(EXPR))) \ + { \ + CONTEXT->handleResult(ERROR, MESSAGE, __FILE__, ANGLE_FUNCTION, __LINE__); \ + return angle::Result::Stop; \ + } \ + } while (0) + +#define ANGLE_HR_UNREACHABLE(context) \ + UNREACHABLE(); \ + ANGLE_CHECK_HR(context, false, "Unreachble code reached.", E_FAIL) + +// Check if the device is lost every 10 failures to get the query data +constexpr unsigned int kPollingD3DDeviceLostCheckFrequency = 10; + +// Useful for unit testing +class BufferFactoryD3D : angle::NonCopyable +{ + public: + BufferFactoryD3D() {} + virtual ~BufferFactoryD3D() {} + + virtual VertexBuffer *createVertexBuffer() = 0; + virtual IndexBuffer *createIndexBuffer() = 0; + + // TODO(jmadill): add VertexFormatCaps + virtual VertexConversionType getVertexConversionType(angle::FormatID vertexFormatID) const = 0; + virtual GLenum getVertexComponentType(angle::FormatID vertexFormatID) const = 0; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + virtual angle::Result getVertexSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *bytesRequiredOut) const = 0; +}; + +using AttribIndexArray = gl::AttribArray<int>; + +class RendererD3D : public BufferFactoryD3D +{ + public: + explicit RendererD3D(egl::Display *display); + ~RendererD3D() override; + + virtual egl::Error initialize() = 0; + + virtual egl::ConfigSet generateConfigs() = 0; + virtual void generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const = 0; + + virtual ContextImpl *createContext(const gl::State &state, gl::ErrorSet *errorSet) = 0; + + virtual std::string getRendererDescription() const = 0; + virtual std::string getVendorString() const = 0; + virtual std::string getVersionString(bool includeFullVersion) const = 0; + + virtual int getMinorShaderModel() const = 0; + virtual std::string getShaderModelSuffix() const = 0; + + // Direct3D Specific methods + virtual DeviceIdentifier getAdapterIdentifier() const = 0; + + virtual bool isValidNativeWindow(EGLNativeWindowType window) const = 0; + virtual NativeWindowD3D *createNativeWindow(EGLNativeWindowType window, + const egl::Config *config, + const egl::AttributeMap &attribs) const = 0; + + virtual SwapChainD3D *createSwapChain(NativeWindowD3D *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) = 0; + virtual egl::Error getD3DTextureInfo(const egl::Config *configuration, + IUnknown *d3dTexture, + const egl::AttributeMap &attribs, + EGLint *width, + EGLint *height, + GLsizei *samples, + gl::Format *glFormat, + const angle::Format **angleFormat, + UINT *arraySlice) const = 0; + virtual egl::Error validateShareHandle(const egl::Config *config, + HANDLE shareHandle, + const egl::AttributeMap &attribs) const = 0; + + virtual int getMajorShaderModel() const = 0; + + virtual void setGlobalDebugAnnotator() = 0; + + const angle::FeaturesD3D &getFeatures() const; + + // Pixel operations + virtual angle::Result copyImage2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) = 0; + virtual angle::Result copyImageCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) = 0; + virtual angle::Result copyImage3D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) = 0; + virtual angle::Result copyImage2DArray(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) = 0; + + virtual angle::Result copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + gl::TextureTarget srcTarget, + const gl::Box &sourceBox, + GLenum destFormat, + GLenum destType, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) = 0; + virtual angle::Result copyCompressedTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + TextureStorage *storage, + GLint destLevel) = 0; + + // RenderTarget creation + virtual angle::Result createRenderTarget(const gl::Context *context, + int width, + int height, + GLenum format, + GLsizei samples, + RenderTargetD3D **outRT) = 0; + virtual angle::Result createRenderTargetCopy(const gl::Context *context, + RenderTargetD3D *source, + RenderTargetD3D **outRT) = 0; + + // Shader operations + virtual angle::Result loadExecutable(d3d::Context *context, + const uint8_t *function, + size_t length, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + ShaderExecutableD3D **outExecutable) = 0; + virtual angle::Result compileToExecutable(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &shaderHLSL, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + const CompilerWorkaroundsD3D &workarounds, + ShaderExecutableD3D **outExectuable) = 0; + virtual angle::Result ensureHLSLCompilerInitialized(d3d::Context *context) = 0; + + virtual UniformStorageD3D *createUniformStorage(size_t storageSize) = 0; + + // Image operations + virtual ImageD3D *createImage() = 0; + virtual ExternalImageSiblingImpl *createExternalImageSibling( + const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) = 0; + virtual angle::Result generateMipmap(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source) = 0; + virtual angle::Result generateMipmapUsingD3D(const gl::Context *context, + TextureStorage *storage, + const gl::TextureState &textureState) = 0; + virtual angle::Result copyImage(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) = 0; + virtual TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorageBuffer( + const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorageExternal( + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorage2D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) = 0; + virtual TextureStorage *createTextureStorageCube(GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorage3D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorage2DMultisample(GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) = 0; + virtual TextureStorage *createTextureStorage2DMultisampleArray(GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) = 0; + + // Buffer-to-texture and Texture-to-buffer copies + virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const = 0; + virtual angle::Result fastCopyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) = 0; + + // Device lost + gl::GraphicsResetStatus getResetStatus(); + void notifyDeviceLost(); + virtual bool resetDevice() = 0; + virtual bool testDeviceLost() = 0; + virtual bool testDeviceResettable() = 0; + + virtual RendererClass getRendererClass() const = 0; + virtual void *getD3DDevice() = 0; + + void setGPUDisjoint(); + + GLint getGPUDisjoint(); + GLint64 getTimestamp(); + + virtual angle::Result clearRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget, + const gl::ColorF &clearColorValue, + const float clearDepthValue, + const unsigned int clearStencilValue) = 0; + + virtual DeviceImpl *createEGLDevice() = 0; + + bool presentPathFastEnabled() const { return mPresentPathFastEnabled; } + + // Stream creation + virtual StreamProducerImpl *createStreamProducerD3DTexture( + egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) = 0; + + const gl::Caps &getNativeCaps() const; + const gl::TextureCapsMap &getNativeTextureCaps() const; + const gl::Extensions &getNativeExtensions() const; + const gl::Limitations &getNativeLimitations() const; + ShPixelLocalStorageType getNativePixelLocalStorageType() const; + virtual void initializeFrontendFeatures(angle::FrontendFeatures *features) const = 0; + + // Necessary hack for default framebuffers in D3D. + virtual FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) = 0; + + virtual gl::Version getMaxSupportedESVersion() const = 0; + virtual gl::Version getMaxConformantESVersion() const = 0; + + angle::Result initRenderTarget(const gl::Context *context, RenderTargetD3D *renderTarget); + + virtual angle::Result getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) = 0; + + Serial generateSerial(); + + virtual bool canSelectViewInVertexShader() const = 0; + + protected: + virtual bool getLUID(LUID *adapterLuid) const = 0; + virtual void generateCaps(gl::Caps *outCaps, + gl::TextureCapsMap *outTextureCaps, + gl::Extensions *outExtensions, + gl::Limitations *outLimitations) const = 0; + + bool skipDraw(const gl::State &glState, gl::PrimitiveMode drawMode); + + egl::Display *mDisplay; + + bool mPresentPathFastEnabled; + + private: + void ensureCapsInitialized() const; + + virtual void initializeFeatures(angle::FeaturesD3D *features) const = 0; + + mutable bool mCapsInitialized; + mutable gl::Caps mNativeCaps; + mutable gl::TextureCapsMap mNativeTextureCaps; + mutable gl::Extensions mNativeExtensions; + mutable gl::Limitations mNativeLimitations; + + mutable bool mFeaturesInitialized; + mutable angle::FeaturesD3D mFeatures; + + bool mDisjoint; + bool mDeviceLost; + + SerialFactory mSerialFactory; +}; + +unsigned int GetBlendSampleMask(const gl::State &glState, int samples); +bool InstancedPointSpritesActive(ProgramD3D *programD3D, gl::PrimitiveMode mode); +GLenum DefaultGLErrorCode(HRESULT hr); + +// Define stubs so we don't need to include D3D9/D3D11 headers directly. +RendererD3D *CreateRenderer11(egl::Display *display); +RendererD3D *CreateRenderer9(egl::Display *display); + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_RENDERERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/SamplerD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SamplerD3D.h new file mode 100644 index 0000000000..ad4b15a4ab --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SamplerD3D.h @@ -0,0 +1,33 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SamplerD3D.h: Defines the rx::SamplerD3D class, an implementation of SamplerImpl. + +#ifndef LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_ +#define LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_ + +#include "libANGLE/renderer/SamplerImpl.h" + +namespace rx +{ + +class SamplerD3D : public SamplerImpl +{ + public: + SamplerD3D(const gl::SamplerState &state) : SamplerImpl(state) {} + ~SamplerD3D() override {} + + angle::Result syncState(const gl::Context *context, const bool dirtyBits) override; +}; + +inline angle::Result SamplerD3D::syncState(const gl::Context *context, const bool dirtyBits) +{ + return angle::Result::Continue; +} + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.cpp new file mode 100644 index 0000000000..ae8a9ebcfb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.cpp @@ -0,0 +1,391 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl. + +#include "libANGLE/renderer/d3d/ShaderD3D.h" + +#include "common/system_utils.h" +#include "common/utilities.h" +#include "libANGLE/Caps.h" +#include "libANGLE/Compiler.h" +#include "libANGLE/Context.h" +#include "libANGLE/Shader.h" +#include "libANGLE/features.h" +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/trace.h" + +namespace rx +{ + +class TranslateTaskD3D : public angle::Closure +{ + public: + TranslateTaskD3D(ShHandle handle, + const ShCompileOptions &options, + const std::string &source, + const std::string &sourcePath) + : mHandle(handle), + mOptions(options), + mSource(source), + mSourcePath(sourcePath), + mResult(false) + {} + + void operator()() override + { + ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTask::run", "source", mSource); + std::vector<const char *> srcStrings; + if (!mSourcePath.empty()) + { + srcStrings.push_back(mSourcePath.c_str()); + } + srcStrings.push_back(mSource.c_str()); + + mResult = sh::Compile(mHandle, &srcStrings[0], srcStrings.size(), mOptions); + } + + bool getResult() { return mResult; } + + private: + ShHandle mHandle; + ShCompileOptions mOptions; + std::string mSource; + std::string mSourcePath; + bool mResult; +}; + +using PostTranslateFunctor = + std::function<bool(gl::ShCompilerInstance *compiler, std::string *infoLog)>; + +class WaitableCompileEventD3D final : public WaitableCompileEvent +{ + public: + WaitableCompileEventD3D(std::shared_ptr<angle::WaitableEvent> waitableEvent, + gl::ShCompilerInstance *compilerInstance, + PostTranslateFunctor &&postTranslateFunctor, + std::shared_ptr<TranslateTaskD3D> translateTask) + : WaitableCompileEvent(waitableEvent), + mCompilerInstance(compilerInstance), + mPostTranslateFunctor(std::move(postTranslateFunctor)), + mTranslateTask(translateTask) + {} + + bool getResult() override { return mTranslateTask->getResult(); } + + bool postTranslate(std::string *infoLog) override + { + return mPostTranslateFunctor(mCompilerInstance, infoLog); + } + + private: + gl::ShCompilerInstance *mCompilerInstance; + PostTranslateFunctor mPostTranslateFunctor; + std::shared_ptr<TranslateTaskD3D> mTranslateTask; +}; + +ShaderD3D::ShaderD3D(const gl::ShaderState &state, RendererD3D *renderer) + : ShaderImpl(state), mRenderer(renderer) +{ + uncompile(); +} + +ShaderD3D::~ShaderD3D() {} + +std::string ShaderD3D::getDebugInfo() const +{ + if (mDebugInfo.empty()) + { + return ""; + } + + return mDebugInfo + std::string("\n// ") + gl::GetShaderTypeString(mState.getShaderType()) + + " SHADER END\n"; +} + +// initialize/clean up previous state +void ShaderD3D::uncompile() +{ + // set by compileToHLSL + mCompilerOutputType = SH_ESSL_OUTPUT; + + mUsesMultipleRenderTargets = false; + mUsesFragColor = false; + mUsesFragData = false; + mUsesSecondaryColor = false; + mUsesFragCoord = false; + mUsesFrontFacing = false; + mUsesHelperInvocation = false; + mUsesPointSize = false; + mUsesPointCoord = false; + mUsesDepthRange = false; + mUsesFragDepth = false; + mHasANGLEMultiviewEnabled = false; + mUsesVertexID = false; + mUsesViewID = false; + mUsesDiscardRewriting = false; + mUsesNestedBreak = false; + mRequiresIEEEStrictCompiling = false; + + mDebugInfo.clear(); +} + +void ShaderD3D::generateWorkarounds(CompilerWorkaroundsD3D *workarounds) const +{ + if (mUsesDiscardRewriting) + { + // ANGLE issue 486: + // Work-around a D3D9 compiler bug that presents itself when using conditional discard, by + // disabling optimization + workarounds->skipOptimization = true; + } + else if (mUsesNestedBreak) + { + // ANGLE issue 603: + // Work-around a D3D9 compiler bug that presents itself when using break in a nested loop, + // by maximizing optimization We want to keep the use of + // ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION minimal to prevent hangs, so usesDiscard takes + // precedence + workarounds->useMaxOptimization = true; + } + + if (mRequiresIEEEStrictCompiling) + { + // IEEE Strictness for D3D compiler needs to be enabled for NaNs to work. + workarounds->enableIEEEStrictness = true; + } +} + +unsigned int ShaderD3D::getUniformRegister(const std::string &uniformName) const +{ + ASSERT(mUniformRegisterMap.count(uniformName) > 0); + return mUniformRegisterMap.find(uniformName)->second; +} + +unsigned int ShaderD3D::getUniformBlockRegister(const std::string &blockName) const +{ + ASSERT(mUniformBlockRegisterMap.count(blockName) > 0); + return mUniformBlockRegisterMap.find(blockName)->second; +} + +bool ShaderD3D::shouldUniformBlockUseStructuredBuffer(const std::string &blockName) const +{ + ASSERT(mUniformBlockUseStructuredBufferMap.count(blockName) > 0); + return mUniformBlockUseStructuredBufferMap.find(blockName)->second; +} + +unsigned int ShaderD3D::getShaderStorageBlockRegister(const std::string &blockName) const +{ + ASSERT(mShaderStorageBlockRegisterMap.count(blockName) > 0); + return mShaderStorageBlockRegisterMap.find(blockName)->second; +} + +ShShaderOutput ShaderD3D::getCompilerOutputType() const +{ + return mCompilerOutputType; +} + +bool ShaderD3D::useImage2DFunction(const std::string &functionName) const +{ + if (mUsedImage2DFunctionNames.empty()) + { + return false; + } + + return mUsedImage2DFunctionNames.find(functionName) != mUsedImage2DFunctionNames.end(); +} + +const std::set<std::string> &ShaderD3D::getSlowCompilingUniformBlockSet() const +{ + return mSlowCompilingUniformBlockSet; +} + +const std::map<std::string, unsigned int> &GetUniformRegisterMap( + const std::map<std::string, unsigned int> *uniformRegisterMap) +{ + ASSERT(uniformRegisterMap); + return *uniformRegisterMap; +} + +const std::set<std::string> &GetSlowCompilingUniformBlockSet( + const std::set<std::string> *slowCompilingUniformBlockSet) +{ + ASSERT(slowCompilingUniformBlockSet); + return *slowCompilingUniformBlockSet; +} + +const std::set<std::string> &GetUsedImage2DFunctionNames( + const std::set<std::string> *usedImage2DFunctionNames) +{ + ASSERT(usedImage2DFunctionNames); + return *usedImage2DFunctionNames; +} + +std::shared_ptr<WaitableCompileEvent> ShaderD3D::compile(const gl::Context *context, + gl::ShCompilerInstance *compilerInstance, + ShCompileOptions *options) +{ + std::string sourcePath; + uncompile(); + + const angle::FeaturesD3D &features = mRenderer->getFeatures(); + const gl::Extensions &extensions = mRenderer->getNativeExtensions(); + + const std::string &source = mState.getSource(); + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + if (gl::DebugAnnotationsActive(context)) + { + sourcePath = angle::CreateTemporaryFile().value(); + writeFile(sourcePath.c_str(), source.c_str(), source.length()); + options->lineDirectives = true; + options->sourcePath = true; + } +#endif + + if (features.expandIntegerPowExpressions.enabled) + { + options->expandSelectHLSLIntegerPowExpressions = true; + } + + if (features.getDimensionsIgnoresBaseLevel.enabled) + { + options->HLSLGetDimensionsIgnoresBaseLevel = true; + } + + if (features.preAddTexelFetchOffsets.enabled) + { + options->rewriteTexelFetchOffsetToTexelFetch = true; + } + if (features.rewriteUnaryMinusOperator.enabled) + { + options->rewriteIntegerUnaryMinusOperator = true; + } + if (features.emulateIsnanFloat.enabled) + { + options->emulateIsnanFloatFunction = true; + } + if (features.skipVSConstantRegisterZero.enabled && + mState.getShaderType() == gl::ShaderType::Vertex) + { + options->skipD3DConstantRegisterZero = true; + } + if (features.forceAtomicValueResolution.enabled) + { + options->forceAtomicValueResolution = true; + } + if (features.allowTranslateUniformBlockToStructuredBuffer.enabled) + { + options->allowTranslateUniformBlockToStructuredBuffer = true; + } + if (extensions.multiviewOVR || extensions.multiview2OVR) + { + options->initializeBuiltinsForInstancedMultiview = true; + } + if (extensions.shaderPixelLocalStorageANGLE) + { + options->pls.type = mRenderer->getNativePixelLocalStorageType(); + if (extensions.shaderPixelLocalStorageCoherentANGLE) + { + options->pls.fragmentSynchronizationType = + ShFragmentSynchronizationType::RasterizerOrderViews_D3D; + } + } + + auto postTranslateFunctor = [this](gl::ShCompilerInstance *compiler, std::string *infoLog) { + // TODO(jmadill): We shouldn't need to cache this. + mCompilerOutputType = compiler->getShaderOutputType(); + + const std::string &translatedSource = mState.getTranslatedSource(); + + mUsesMultipleRenderTargets = translatedSource.find("GL_USES_MRT") != std::string::npos; + mUsesFragColor = translatedSource.find("GL_USES_FRAG_COLOR") != std::string::npos; + mUsesFragData = translatedSource.find("GL_USES_FRAG_DATA") != std::string::npos; + mUsesSecondaryColor = translatedSource.find("GL_USES_SECONDARY_COLOR") != std::string::npos; + mUsesFragCoord = translatedSource.find("GL_USES_FRAG_COORD") != std::string::npos; + mUsesFrontFacing = translatedSource.find("GL_USES_FRONT_FACING") != std::string::npos; + mUsesHelperInvocation = + translatedSource.find("GL_USES_HELPER_INVOCATION") != std::string::npos; + mUsesPointSize = translatedSource.find("GL_USES_POINT_SIZE") != std::string::npos; + mUsesPointCoord = translatedSource.find("GL_USES_POINT_COORD") != std::string::npos; + mUsesDepthRange = translatedSource.find("GL_USES_DEPTH_RANGE") != std::string::npos; + mUsesFragDepth = translatedSource.find("GL_USES_FRAG_DEPTH") != std::string::npos; + mHasANGLEMultiviewEnabled = + translatedSource.find("GL_ANGLE_MULTIVIEW_ENABLED") != std::string::npos; + mUsesVertexID = translatedSource.find("GL_USES_VERTEX_ID") != std::string::npos; + mUsesViewID = translatedSource.find("GL_USES_VIEW_ID") != std::string::npos; + mUsesDiscardRewriting = + translatedSource.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos; + mUsesNestedBreak = translatedSource.find("ANGLE_USES_NESTED_BREAK") != std::string::npos; + mRequiresIEEEStrictCompiling = + translatedSource.find("ANGLE_REQUIRES_IEEE_STRICT_COMPILING") != std::string::npos; + + ShHandle compilerHandle = compiler->getHandle(); + + mUniformRegisterMap = GetUniformRegisterMap(sh::GetUniformRegisterMap(compilerHandle)); + mReadonlyImage2DRegisterIndex = sh::GetReadonlyImage2DRegisterIndex(compilerHandle); + mImage2DRegisterIndex = sh::GetImage2DRegisterIndex(compilerHandle); + mUsedImage2DFunctionNames = + GetUsedImage2DFunctionNames(sh::GetUsedImage2DFunctionNames(compilerHandle)); + + for (const sh::InterfaceBlock &interfaceBlock : mState.getUniformBlocks()) + { + if (interfaceBlock.active) + { + unsigned int index = static_cast<unsigned int>(-1); + bool blockRegisterResult = + sh::GetUniformBlockRegister(compilerHandle, interfaceBlock.name, &index); + ASSERT(blockRegisterResult); + bool useStructuredBuffer = + sh::ShouldUniformBlockUseStructuredBuffer(compilerHandle, interfaceBlock.name); + + mUniformBlockRegisterMap[interfaceBlock.name] = index; + mUniformBlockUseStructuredBufferMap[interfaceBlock.name] = useStructuredBuffer; + } + } + + mSlowCompilingUniformBlockSet = + GetSlowCompilingUniformBlockSet(sh::GetSlowCompilingUniformBlockSet(compilerHandle)); + + for (const sh::InterfaceBlock &interfaceBlock : mState.getShaderStorageBlocks()) + { + if (interfaceBlock.active) + { + unsigned int index = static_cast<unsigned int>(-1); + bool blockRegisterResult = + sh::GetShaderStorageBlockRegister(compilerHandle, interfaceBlock.name, &index); + ASSERT(blockRegisterResult); + + mShaderStorageBlockRegisterMap[interfaceBlock.name] = index; + } + } + + mDebugInfo += std::string("// ") + gl::GetShaderTypeString(mState.getShaderType()) + + " SHADER BEGIN\n"; + mDebugInfo += "\n// GLSL BEGIN\n\n" + mState.getSource() + "\n\n// GLSL END\n\n\n"; + mDebugInfo += + "// INITIAL HLSL BEGIN\n\n" + translatedSource + "\n// INITIAL HLSL END\n\n\n"; + // Successive steps will append more info + return true; + }; + + auto workerThreadPool = context->getWorkerThreadPool(); + auto translateTask = std::make_shared<TranslateTaskD3D>(compilerInstance->getHandle(), *options, + source, sourcePath); + + return std::make_shared<WaitableCompileEventD3D>( + angle::WorkerThreadPool::PostWorkerTask(workerThreadPool, translateTask), compilerInstance, + std::move(postTranslateFunctor), translateTask); +} + +bool ShaderD3D::hasUniform(const std::string &name) const +{ + return mUniformRegisterMap.find(name) != mUniformRegisterMap.end(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.h new file mode 100644 index 0000000000..d1c5622a27 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderD3D.h @@ -0,0 +1,126 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderD3D.h: Defines the rx::ShaderD3D class which implements rx::ShaderImpl. + +#ifndef LIBANGLE_RENDERER_D3D_SHADERD3D_H_ +#define LIBANGLE_RENDERER_D3D_SHADERD3D_H_ + +#include "libANGLE/renderer/ShaderImpl.h" + +#include <map> + +namespace angle +{ +struct FeaturesD3D; +} // namespace angle + +namespace gl +{ +struct Extensions; +} + +namespace rx +{ +class DynamicHLSL; +class RendererD3D; +struct D3DUniform; + +// Workarounds attached to each shader. Do not need to expose information about these workarounds so +// a simple bool struct suffices. +struct CompilerWorkaroundsD3D +{ + bool skipOptimization = false; + + bool useMaxOptimization = false; + + // IEEE strictness needs to be enabled for NANs to work. + bool enableIEEEStrictness = false; +}; + +class ShaderD3D : public ShaderImpl +{ + public: + ShaderD3D(const gl::ShaderState &state, RendererD3D *renderer); + ~ShaderD3D() override; + + std::shared_ptr<WaitableCompileEvent> compile(const gl::Context *context, + gl::ShCompilerInstance *compilerInstance, + ShCompileOptions *options) override; + + std::string getDebugInfo() const override; + + // D3D-specific methods + void uncompile(); + + bool hasUniform(const std::string &name) const; + + // Query regular uniforms with their name. Query sampler fields of structs with field selection + // using dot (.) operator. + unsigned int getUniformRegister(const std::string &uniformName) const; + + unsigned int getUniformBlockRegister(const std::string &blockName) const; + bool shouldUniformBlockUseStructuredBuffer(const std::string &blockName) const; + unsigned int getShaderStorageBlockRegister(const std::string &blockName) const; + unsigned int getReadonlyImage2DRegisterIndex() const { return mReadonlyImage2DRegisterIndex; } + unsigned int getImage2DRegisterIndex() const { return mImage2DRegisterIndex; } + bool useImage2DFunction(const std::string &functionName) const; + const std::set<std::string> &getSlowCompilingUniformBlockSet() const; + void appendDebugInfo(const std::string &info) const { mDebugInfo += info; } + + void generateWorkarounds(CompilerWorkaroundsD3D *workarounds) const; + + bool usesMultipleRenderTargets() const { return mUsesMultipleRenderTargets; } + bool usesFragColor() const { return mUsesFragColor; } + bool usesFragData() const { return mUsesFragData; } + bool usesSecondaryColor() const { return mUsesSecondaryColor; } + bool usesFragCoord() const { return mUsesFragCoord; } + bool usesFrontFacing() const { return mUsesFrontFacing; } + bool usesHelperInvocation() const { return mUsesHelperInvocation; } + bool usesPointSize() const { return mUsesPointSize; } + bool usesPointCoord() const { return mUsesPointCoord; } + bool usesDepthRange() const { return mUsesDepthRange; } + bool usesFragDepth() const { return mUsesFragDepth; } + bool usesVertexID() const { return mUsesVertexID; } + bool usesViewID() const { return mUsesViewID; } + bool hasANGLEMultiviewEnabled() const { return mHasANGLEMultiviewEnabled; } + + ShShaderOutput getCompilerOutputType() const; + + private: + bool mUsesMultipleRenderTargets; + bool mUsesFragColor; + bool mUsesFragData; + bool mUsesSecondaryColor; + bool mUsesFragCoord; + bool mUsesFrontFacing; + bool mUsesHelperInvocation; + bool mUsesPointSize; + bool mUsesPointCoord; + bool mUsesDepthRange; + bool mUsesFragDepth; + bool mHasANGLEMultiviewEnabled; + bool mUsesVertexID; + bool mUsesViewID; + bool mUsesDiscardRewriting; + bool mUsesNestedBreak; + bool mRequiresIEEEStrictCompiling; + + RendererD3D *mRenderer; + ShShaderOutput mCompilerOutputType; + mutable std::string mDebugInfo; + std::map<std::string, unsigned int> mUniformRegisterMap; + std::map<std::string, unsigned int> mUniformBlockRegisterMap; + std::map<std::string, bool> mUniformBlockUseStructuredBufferMap; + std::set<std::string> mSlowCompilingUniformBlockSet; + std::map<std::string, unsigned int> mShaderStorageBlockRegisterMap; + unsigned int mReadonlyImage2DRegisterIndex; + unsigned int mImage2DRegisterIndex; + std::set<std::string> mUsedImage2DFunctionNames; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_SHADERD3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.cpp new file mode 100644 index 0000000000..eab3becc91 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.cpp @@ -0,0 +1,67 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable.cpp: Implements a class to contain D3D shader executable +// implementation details. + +#include "libANGLE/renderer/d3d/ShaderExecutableD3D.h" + +#include "common/angleutils.h" + +namespace rx +{ + +ShaderExecutableD3D::ShaderExecutableD3D(const void *function, size_t length) + : mFunctionBuffer(length) +{ + memcpy(mFunctionBuffer.data(), function, length); +} + +ShaderExecutableD3D::~ShaderExecutableD3D() {} + +const uint8_t *ShaderExecutableD3D::getFunction() const +{ + return mFunctionBuffer.data(); +} + +size_t ShaderExecutableD3D::getLength() const +{ + return mFunctionBuffer.size(); +} + +const std::string &ShaderExecutableD3D::getDebugInfo() const +{ + return mDebugInfo; +} + +void ShaderExecutableD3D::appendDebugInfo(const std::string &info) +{ + mDebugInfo += info; +} + +UniformStorageD3D::UniformStorageD3D(size_t initialSize) : mUniformData() +{ + bool result = mUniformData.resize(initialSize); + ASSERT(result); + + // Uniform data is zero-initialized by default. + mUniformData.fill(0); +} + +UniformStorageD3D::~UniformStorageD3D() {} + +size_t UniformStorageD3D::size() const +{ + return mUniformData.size(); +} + +uint8_t *UniformStorageD3D::getDataPointer(unsigned int registerIndex, unsigned int registerElement) +{ + size_t offset = ((registerIndex * 4 + registerElement) * sizeof(float)); + return mUniformData.data() + offset; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.h new file mode 100644 index 0000000000..673822b152 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/ShaderExecutableD3D.h @@ -0,0 +1,57 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable.h: Defines a class to contain D3D shader executable +// implementation details. + +#ifndef LIBANGLE_RENDERER_D3D_SHADEREXECUTABLED3D_H_ +#define LIBANGLE_RENDERER_D3D_SHADEREXECUTABLED3D_H_ + +#include "common/MemoryBuffer.h" +#include "common/debug.h" + +#include <cstdint> +#include <vector> + +namespace rx +{ + +class ShaderExecutableD3D : angle::NonCopyable +{ + public: + ShaderExecutableD3D(const void *function, size_t length); + virtual ~ShaderExecutableD3D(); + + const uint8_t *getFunction() const; + + size_t getLength() const; + + const std::string &getDebugInfo() const; + + void appendDebugInfo(const std::string &info); + + private: + std::vector<uint8_t> mFunctionBuffer; + std::string mDebugInfo; +}; + +class UniformStorageD3D : angle::NonCopyable +{ + public: + UniformStorageD3D(size_t initialSize); + virtual ~UniformStorageD3D(); + + size_t size() const; + + uint8_t *getDataPointer(unsigned int registerIndex, unsigned int registerElement); + + private: + angle::MemoryBuffer mUniformData; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_SHADEREXECUTABLED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.cpp new file mode 100644 index 0000000000..256808637f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.cpp @@ -0,0 +1,517 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SurfaceD3D.cpp: D3D implementation of an EGL surface + +#include "libANGLE/renderer/d3d/SurfaceD3D.h" + +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/Surface.h" +#include "libANGLE/renderer/Format.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/SwapChainD3D.h" + +#include <EGL/eglext.h> +#include <tchar.h> +#include <algorithm> + +namespace rx +{ + +SurfaceD3D::SurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLNativeWindowType window, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) + : SurfaceImpl(state), + mRenderer(renderer), + mDisplay(display), + mFixedSize(window == nullptr || attribs.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE) == EGL_TRUE), + mFixedWidth(0), + mFixedHeight(0), + mOrientation(static_cast<EGLint>(attribs.get(EGL_SURFACE_ORIENTATION_ANGLE, 0))), + mRenderTargetFormat(state.config->renderTargetFormat), + mDepthStencilFormat(state.config->depthStencilFormat), + mColorFormat(nullptr), + mSwapChain(nullptr), + mSwapIntervalDirty(true), + mNativeWindow(renderer->createNativeWindow(window, state.config, attribs)), + mWidth(static_cast<EGLint>(attribs.get(EGL_WIDTH, 0))), + mHeight(static_cast<EGLint>(attribs.get(EGL_HEIGHT, 0))), + mSwapInterval(1), + mShareHandle(0), + mD3DTexture(nullptr), + mBuftype(buftype) +{ + if (window != nullptr && !mFixedSize) + { + mWidth = -1; + mHeight = -1; + } + + if (mFixedSize) + { + mFixedWidth = mWidth; + mFixedHeight = mHeight; + } + + switch (buftype) + { + case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE: + mShareHandle = static_cast<HANDLE>(clientBuffer); + break; + + case EGL_D3D_TEXTURE_ANGLE: + mD3DTexture = static_cast<IUnknown *>(clientBuffer); + ASSERT(mD3DTexture != nullptr); + mD3DTexture->AddRef(); + break; + + default: + break; + } +} + +SurfaceD3D::~SurfaceD3D() +{ + releaseSwapChain(); + SafeDelete(mNativeWindow); + SafeRelease(mD3DTexture); +} + +void SurfaceD3D::releaseSwapChain() +{ + SafeDelete(mSwapChain); +} + +egl::Error SurfaceD3D::initialize(const egl::Display *display) +{ + if (mNativeWindow->getNativeWindow()) + { + if (!mNativeWindow->initialize()) + { + return egl::EglBadSurface(); + } + } + + if (mBuftype == EGL_D3D_TEXTURE_ANGLE) + { + ANGLE_TRY(mRenderer->getD3DTextureInfo(mState.config, mD3DTexture, mState.attributes, + &mFixedWidth, &mFixedHeight, nullptr, nullptr, + &mColorFormat, nullptr)); + if (mState.attributes.contains(EGL_GL_COLORSPACE)) + { + if (mColorFormat->id != angle::FormatID::R8G8B8A8_TYPELESS && + mColorFormat->id != angle::FormatID::B8G8R8A8_TYPELESS) + { + return egl::EglBadMatch() + << "EGL_GL_COLORSPACE may only be specified for TYPELESS textures"; + } + } + if (mColorFormat->id == angle::FormatID::R8G8B8A8_TYPELESS) + { + EGLAttrib colorspace = + mState.attributes.get(EGL_GL_COLORSPACE, EGL_GL_COLORSPACE_LINEAR); + if (colorspace == EGL_GL_COLORSPACE_SRGB) + { + mColorFormat = &angle::Format::Get(angle::FormatID::R8G8B8A8_TYPELESS_SRGB); + } + } + if (mColorFormat->id == angle::FormatID::B8G8R8A8_TYPELESS) + { + EGLAttrib colorspace = + mState.attributes.get(EGL_GL_COLORSPACE, EGL_GL_COLORSPACE_LINEAR); + if (colorspace == EGL_GL_COLORSPACE_SRGB) + { + mColorFormat = &angle::Format::Get(angle::FormatID::B8G8R8A8_TYPELESS_SRGB); + } + } + mRenderTargetFormat = mColorFormat->fboImplementationInternalFormat; + } + + ANGLE_TRY(resetSwapChain(display)); + return egl::NoError(); +} + +egl::Error SurfaceD3D::bindTexImage(const gl::Context *, gl::Texture *, EGLint) +{ + return egl::NoError(); +} + +egl::Error SurfaceD3D::releaseTexImage(const gl::Context *, EGLint) +{ + return egl::NoError(); +} + +egl::Error SurfaceD3D::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) +{ + if (!mState.directComposition) + { + return egl::EglBadSurface() + << "getSyncValues: surface requires Direct Composition to be enabled"; + } + + return mSwapChain->getSyncValues(ust, msc, sbc); +} + +egl::Error SurfaceD3D::getMscRate(EGLint *numerator, EGLint *denominator) +{ + UNIMPLEMENTED(); + return egl::EglBadAccess(); +} + +egl::Error SurfaceD3D::resetSwapChain(const egl::Display *display) +{ + ASSERT(!mSwapChain); + + int width; + int height; + + if (!mFixedSize) + { + RECT windowRect; + if (!mNativeWindow->getClientRect(&windowRect)) + { + ASSERT(false); + + return egl::EglBadSurface() << "Could not retrieve the window dimensions"; + } + + width = windowRect.right - windowRect.left; + height = windowRect.bottom - windowRect.top; + } + else + { + // non-window surface - size is determined at creation + width = mFixedWidth; + height = mFixedHeight; + } + + mSwapChain = + mRenderer->createSwapChain(mNativeWindow, mShareHandle, mD3DTexture, mRenderTargetFormat, + mDepthStencilFormat, mOrientation, mState.config->samples); + if (!mSwapChain) + { + return egl::EglBadAlloc(); + } + + // This is a bit risky to pass the proxy context here, but it can happen at almost any time. + DisplayD3D *displayD3D = GetImplAs<DisplayD3D>(display); + egl::Error error = resetSwapChain(displayD3D, width, height); + if (error.isError()) + { + SafeDelete(mSwapChain); + return error; + } + + return egl::NoError(); +} + +egl::Error SurfaceD3D::resizeSwapChain(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight) +{ + ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0); + ASSERT(mSwapChain); + + EGLint status = + mSwapChain->resize(displayD3D, std::max(1, backbufferWidth), std::max(1, backbufferHeight)); + + if (status == EGL_CONTEXT_LOST) + { + mDisplay->notifyDeviceLost(); + return egl::Error(status); + } + else if (status != EGL_SUCCESS) + { + return egl::Error(status); + } + + mWidth = backbufferWidth; + mHeight = backbufferHeight; + + return egl::NoError(); +} + +egl::Error SurfaceD3D::resetSwapChain(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight) +{ + ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0); + ASSERT(mSwapChain); + + EGLint status = mSwapChain->reset(displayD3D, std::max(1, backbufferWidth), + std::max(1, backbufferHeight), mSwapInterval); + + if (status == EGL_CONTEXT_LOST) + { + mRenderer->notifyDeviceLost(); + return egl::Error(status); + } + else if (status != EGL_SUCCESS) + { + return egl::Error(status); + } + + mWidth = backbufferWidth; + mHeight = backbufferHeight; + mSwapIntervalDirty = false; + + return egl::NoError(); +} + +egl::Error SurfaceD3D::swapRect(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + if (!mSwapChain) + { + return egl::NoError(); + } + + if (x + width > mWidth) + { + width = mWidth - x; + } + + if (y + height > mHeight) + { + height = mHeight - y; + } + + if (width != 0 && height != 0) + { + EGLint status = mSwapChain->swapRect(displayD3D, x, y, width, height); + + if (status == EGL_CONTEXT_LOST) + { + mRenderer->notifyDeviceLost(); + return egl::Error(status); + } + else if (status != EGL_SUCCESS) + { + return egl::Error(status); + } + } + + ANGLE_TRY(checkForOutOfDateSwapChain(displayD3D)); + + return egl::NoError(); +} + +egl::Error SurfaceD3D::checkForOutOfDateSwapChain(DisplayD3D *displayD3D) +{ + RECT client; + int clientWidth = getWidth(); + int clientHeight = getHeight(); + bool sizeDirty = false; + if (!mFixedSize && !mNativeWindow->isIconic()) + { + // The window is automatically resized to 150x22 when it's minimized, but the swapchain + // shouldn't be resized because that's not a useful size to render to. + if (!mNativeWindow->getClientRect(&client)) + { + UNREACHABLE(); + return egl::NoError(); + } + + // Grow the buffer now, if the window has grown. We need to grow now to avoid losing + // information. + clientWidth = client.right - client.left; + clientHeight = client.bottom - client.top; + sizeDirty = clientWidth != getWidth() || clientHeight != getHeight(); + } + else if (mFixedSize) + { + clientWidth = mFixedWidth; + clientHeight = mFixedHeight; + sizeDirty = mFixedWidth != getWidth() || mFixedHeight != getHeight(); + } + + if (mSwapIntervalDirty) + { + ANGLE_TRY(resetSwapChain(displayD3D, clientWidth, clientHeight)); + } + else if (sizeDirty) + { + ANGLE_TRY(resizeSwapChain(displayD3D, clientWidth, clientHeight)); + } + + return egl::NoError(); +} + +egl::Error SurfaceD3D::swap(const gl::Context *context) +{ + DisplayD3D *displayD3D = GetImplAs<DisplayD3D>(context->getDisplay()); + return swapRect(displayD3D, 0, 0, mWidth, mHeight); +} + +egl::Error SurfaceD3D::postSubBuffer(const gl::Context *context, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + DisplayD3D *displayD3D = GetImplAs<DisplayD3D>(context->getDisplay()); + return swapRect(displayD3D, x, y, width, height); +} + +rx::SwapChainD3D *SurfaceD3D::getSwapChain() const +{ + return mSwapChain; +} + +void SurfaceD3D::setSwapInterval(EGLint interval) +{ + if (mSwapInterval == interval) + { + return; + } + + mSwapInterval = interval; + mSwapIntervalDirty = true; +} + +void SurfaceD3D::setFixedWidth(EGLint width) +{ + mFixedWidth = width; +} + +void SurfaceD3D::setFixedHeight(EGLint height) +{ + mFixedHeight = height; +} + +EGLint SurfaceD3D::getWidth() const +{ + return mWidth; +} + +EGLint SurfaceD3D::getHeight() const +{ + return mHeight; +} + +EGLint SurfaceD3D::isPostSubBufferSupported() const +{ + // post sub buffer is always possible on D3D surfaces + return EGL_TRUE; +} + +EGLint SurfaceD3D::getSwapBehavior() const +{ + return EGL_BUFFER_PRESERVED; +} + +egl::Error SurfaceD3D::querySurfacePointerANGLE(EGLint attribute, void **value) +{ + if (attribute == EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE) + { + *value = mSwapChain->getShareHandle(); + } + else if (attribute == EGL_DXGI_KEYED_MUTEX_ANGLE) + { + *value = mSwapChain->getKeyedMutex(); + } + else + UNREACHABLE(); + + return egl::NoError(); +} + +const angle::Format *SurfaceD3D::getD3DTextureColorFormat() const +{ + return mColorFormat; +} + +egl::Error SurfaceD3D::attachToFramebuffer(const gl::Context *context, gl::Framebuffer *framebuffer) +{ + return egl::NoError(); +} + +egl::Error SurfaceD3D::detachFromFramebuffer(const gl::Context *context, + gl::Framebuffer *framebuffer) +{ + return egl::NoError(); +} + +angle::Result SurfaceD3D::getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) +{ + if (binding == GL_BACK) + { + *rtOut = mSwapChain->getColorRenderTarget(); + } + else + { + *rtOut = mSwapChain->getDepthStencilRenderTarget(); + } + return angle::Result::Continue; +} + +angle::Result SurfaceD3D::initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) +{ + switch (binding) + { + case GL_BACK: + ASSERT(mState.config->renderTargetFormat != GL_NONE); + ANGLE_TRY(mRenderer->initRenderTarget(context, mSwapChain->getColorRenderTarget())); + break; + + case GL_DEPTH: + case GL_STENCIL: + ASSERT(mState.config->depthStencilFormat != GL_NONE); + ANGLE_TRY( + mRenderer->initRenderTarget(context, mSwapChain->getDepthStencilRenderTarget())); + break; + + default: + UNREACHABLE(); + break; + } + return angle::Result::Continue; +} + +WindowSurfaceD3D::WindowSurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLNativeWindowType window, + const egl::AttributeMap &attribs) + : SurfaceD3D(state, renderer, display, window, 0, static_cast<EGLClientBuffer>(0), attribs) +{} + +WindowSurfaceD3D::~WindowSurfaceD3D() {} + +PbufferSurfaceD3D::PbufferSurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs) + : SurfaceD3D(state, + renderer, + display, + static_cast<EGLNativeWindowType>(0), + buftype, + clientBuffer, + attribs) +{} + +PbufferSurfaceD3D::~PbufferSurfaceD3D() {} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.h new file mode 100644 index 0000000000..720943c8d1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SurfaceD3D.h @@ -0,0 +1,145 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SurfaceD3D.h: D3D implementation of an EGL surface + +#ifndef LIBANGLE_RENDERER_D3D_SURFACED3D_H_ +#define LIBANGLE_RENDERER_D3D_SURFACED3D_H_ + +#include "libANGLE/renderer/SurfaceImpl.h" +#include "libANGLE/renderer/d3d/NativeWindowD3D.h" + +namespace egl +{ +class Surface; +} + +namespace rx +{ +class DisplayD3D; +class SwapChainD3D; +class RendererD3D; + +class SurfaceD3D : public SurfaceImpl +{ + public: + ~SurfaceD3D() override; + void releaseSwapChain(); + + egl::Error initialize(const egl::Display *display) override; + + egl::Error swap(const gl::Context *context) override; + egl::Error postSubBuffer(const gl::Context *context, + EGLint x, + EGLint y, + EGLint width, + EGLint height) override; + egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override; + egl::Error bindTexImage(const gl::Context *context, + gl::Texture *texture, + EGLint buffer) override; + egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override; + egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override; + egl::Error getMscRate(EGLint *numerator, EGLint *denominator) override; + void setSwapInterval(EGLint interval) override; + void setFixedWidth(EGLint width) override; + void setFixedHeight(EGLint height) override; + + EGLint getWidth() const override; + EGLint getHeight() const override; + + EGLint isPostSubBufferSupported() const override; + EGLint getSwapBehavior() const override; + + // D3D implementations + SwapChainD3D *getSwapChain() const; + + egl::Error resetSwapChain(const egl::Display *display); + + egl::Error checkForOutOfDateSwapChain(DisplayD3D *displayD3D); + + angle::Result getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) override; + angle::Result initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) override; + + const angle::Format *getD3DTextureColorFormat() const override; + + egl::Error attachToFramebuffer(const gl::Context *context, + gl::Framebuffer *framebuffer) override; + egl::Error detachFromFramebuffer(const gl::Context *context, + gl::Framebuffer *framebuffer) override; + + protected: + SurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLNativeWindowType window, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs); + + egl::Error swapRect(DisplayD3D *displayD3D, EGLint x, EGLint y, EGLint width, EGLint height); + egl::Error resetSwapChain(DisplayD3D *displayD3D, int backbufferWidth, int backbufferHeight); + egl::Error resizeSwapChain(DisplayD3D *displayD3D, int backbufferWidth, int backbufferHeight); + + RendererD3D *mRenderer; + egl::Display *mDisplay; + + bool mFixedSize; + GLint mFixedWidth; + GLint mFixedHeight; + GLint mOrientation; + + GLenum mRenderTargetFormat; + GLenum mDepthStencilFormat; + const angle::Format *mColorFormat; + + SwapChainD3D *mSwapChain; + bool mSwapIntervalDirty; + + NativeWindowD3D *mNativeWindow; // Handler for the Window that the surface is created for. + EGLint mWidth; + EGLint mHeight; + + EGLint mSwapInterval; + + HANDLE mShareHandle; + IUnknown *mD3DTexture; + + EGLenum mBuftype; +}; + +class WindowSurfaceD3D : public SurfaceD3D +{ + public: + WindowSurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLNativeWindowType window, + const egl::AttributeMap &attribs); + ~WindowSurfaceD3D() override; +}; + +class PbufferSurfaceD3D : public SurfaceD3D +{ + public: + PbufferSurfaceD3D(const egl::SurfaceState &state, + RendererD3D *renderer, + egl::Display *display, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs); + ~PbufferSurfaceD3D() override; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_SURFACED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.cpp new file mode 100644 index 0000000000..8891888a68 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.cpp @@ -0,0 +1,34 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChainD3D.cpp: Defines a back-end specific class that hides the details of the +// implementation-specific swapchain. + +#include "libANGLE/renderer/d3d/SwapChainD3D.h" + +namespace rx +{ + +SwapChainD3D::SwapChainD3D(HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat) + : mOffscreenRenderTargetFormat(backBufferFormat), + mDepthBufferFormat(depthBufferFormat), + mShareHandle(shareHandle), + mD3DTexture(d3dTexture) +{ + if (mD3DTexture) + { + mD3DTexture->AddRef(); + } +} + +SwapChainD3D::~SwapChainD3D() +{ + SafeRelease(mD3DTexture); +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.h new file mode 100644 index 0000000000..fcbab95c8d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/SwapChainD3D.h @@ -0,0 +1,83 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChainD3D.h: Defines a back-end specific class that hides the details of the +// implementation-specific swapchain. + +#ifndef LIBANGLE_RENDERER_D3D_SWAPCHAIND3D_H_ +#define LIBANGLE_RENDERER_D3D_SWAPCHAIND3D_H_ + +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <GLES2/gl2.h> + +#include "common/angleutils.h" +#include "common/platform.h" +#include "libANGLE/Error.h" + +#if !defined(ANGLE_FORCE_VSYNC_OFF) +# define ANGLE_FORCE_VSYNC_OFF 0 +#endif + +namespace gl +{ +class Context; +} // namespace gl + +namespace egl +{ +class Display; +} // namespace egl + +namespace rx +{ +class DisplayD3D; +class RenderTargetD3D; + +class SwapChainD3D : angle::NonCopyable +{ + public: + SwapChainD3D(HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat); + virtual ~SwapChainD3D(); + + virtual EGLint resize(DisplayD3D *displayD3D, + EGLint backbufferWidth, + EGLint backbufferSize) = 0; + virtual EGLint reset(DisplayD3D *displayD3D, + EGLint backbufferWidth, + EGLint backbufferHeight, + EGLint swapInterval) = 0; + virtual EGLint swapRect(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) = 0; + virtual void recreate() = 0; + + virtual RenderTargetD3D *getColorRenderTarget() = 0; + virtual RenderTargetD3D *getDepthStencilRenderTarget() = 0; + + GLenum getRenderTargetInternalFormat() const { return mOffscreenRenderTargetFormat; } + GLenum getDepthBufferInternalFormat() const { return mDepthBufferFormat; } + + HANDLE getShareHandle() { return mShareHandle; } + virtual void *getKeyedMutex() = 0; + + virtual egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) = 0; + + protected: + const GLenum mOffscreenRenderTargetFormat; + const GLenum mDepthBufferFormat; + + HANDLE mShareHandle; + IUnknown *mD3DTexture; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D_SWAPCHAIND3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.cpp new file mode 100644 index 0000000000..fc22f000be --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.cpp @@ -0,0 +1,4640 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureD3D.cpp: Implementations of the Texture interfaces shared betweeen the D3D backends. + +#include "libANGLE/renderer/d3d/TextureD3D.h" + +#include "common/mathutil.h" +#include "common/utilities.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Config.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/Image.h" +#include "libANGLE/Surface.h" +#include "libANGLE/Texture.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/BufferImpl.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/EGLImageD3D.h" +#include "libANGLE/renderer/d3d/ImageD3D.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/SurfaceD3D.h" +#include "libANGLE/renderer/d3d/TextureStorage.h" + +namespace rx +{ + +namespace +{ + +angle::Result GetUnpackPointer(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + ptrdiff_t layerOffset, + const uint8_t **pointerOut) +{ + if (unpackBuffer) + { + // Do a CPU readback here, if we have an unpack buffer bound and the fast GPU path is not + // supported + ptrdiff_t offset = reinterpret_cast<ptrdiff_t>(pixels); + + // TODO: this is the only place outside of renderer that asks for a buffers raw data. + // This functionality should be moved into renderer and the getData method of BufferImpl + // removed. + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(unpackBuffer); + ASSERT(bufferD3D); + const uint8_t *bufferData = nullptr; + ANGLE_TRY(bufferD3D->getData(context, &bufferData)); + *pointerOut = bufferData + offset; + } + else + { + *pointerOut = pixels; + } + + // Offset the pointer for 2D array layer (if it's valid) + if (*pointerOut != nullptr) + { + *pointerOut += layerOffset; + } + + return angle::Result::Continue; +} + +bool IsRenderTargetUsage(GLenum usage) +{ + return (usage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE); +} +} // namespace + +TextureD3D::TextureD3D(const gl::TextureState &state, RendererD3D *renderer) + : TextureImpl(state), + mRenderer(renderer), + mDirtyImages(true), + mImmutable(false), + mTexStorage(nullptr), + mTexStorageObserverBinding(this, kTextureStorageObserverMessageIndex), + mBaseLevel(0) +{} + +TextureD3D::~TextureD3D() +{ + ASSERT(!mTexStorage); +} + +angle::Result TextureD3D::getNativeTexture(const gl::Context *context, TextureStorage **outStorage) +{ + // ensure the underlying texture is created + ANGLE_TRY(initializeStorage(context, BindFlags())); + + if (mTexStorage) + { + ANGLE_TRY(updateStorage(context)); + } + + ASSERT(outStorage); + + *outStorage = mTexStorage; + return angle::Result::Continue; +} + +angle::Result TextureD3D::getImageAndSyncFromStorage(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D **outImage) +{ + ImageD3D *image = getImage(index); + if (mTexStorage && mTexStorage->isRenderTarget()) + { + ANGLE_TRY(image->copyFromTexStorage(context, index, mTexStorage)); + mDirtyImages = true; + } + image->markClean(); + *outImage = image; + return angle::Result::Continue; +} + +GLint TextureD3D::getLevelZeroWidth() const +{ + ASSERT(gl::CountLeadingZeros(static_cast<uint32_t>(getBaseLevelWidth())) > getBaseLevel()); + return getBaseLevelWidth() << mBaseLevel; +} + +GLint TextureD3D::getLevelZeroHeight() const +{ + ASSERT(gl::CountLeadingZeros(static_cast<uint32_t>(getBaseLevelHeight())) > getBaseLevel()); + return getBaseLevelHeight() << mBaseLevel; +} + +GLint TextureD3D::getLevelZeroDepth() const +{ + return getBaseLevelDepth(); +} + +GLint TextureD3D::getBaseLevelWidth() const +{ + const ImageD3D *baseImage = getBaseLevelImage(); + return (baseImage ? baseImage->getWidth() : 0); +} + +GLint TextureD3D::getBaseLevelHeight() const +{ + const ImageD3D *baseImage = getBaseLevelImage(); + return (baseImage ? baseImage->getHeight() : 0); +} + +GLint TextureD3D::getBaseLevelDepth() const +{ + const ImageD3D *baseImage = getBaseLevelImage(); + return (baseImage ? baseImage->getDepth() : 0); +} + +// Note: "base level image" is loosely defined to be any image from the base level, +// where in the base of 2D array textures and cube maps there are several. Don't use +// the base level image for anything except querying texture format and size. +GLenum TextureD3D::getBaseLevelInternalFormat() const +{ + const ImageD3D *baseImage = getBaseLevelImage(); + return (baseImage ? baseImage->getInternalFormat() : GL_NONE); +} + +angle::Result TextureD3D::setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D::setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D::setBuffer(const gl::Context *context, GLenum internalFormat) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D::setStorageExternalMemory(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size, + gl::MemoryObject *memoryObject, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +bool TextureD3D::couldUseSetData() const +{ + if (!mRenderer->getFeatures().setDataFasterThanImageUpload.enabled) + { + return false; + } + + if (!mRenderer->getFeatures().setDataFasterThanImageUploadOn128bitFormats.enabled) + { + gl::InternalFormat internalFormat = + gl::GetSizedInternalFormatInfo(getBaseLevelInternalFormat()); + return internalFormat.pixelBytes < 16; + } + + return true; +} + +bool TextureD3D::shouldUseSetData(const ImageD3D *image) const +{ + if (!couldUseSetData()) + { + return false; + } + + if (image->isDirty()) + { + return false; + } + + gl::InternalFormat internalFormat = gl::GetSizedInternalFormatInfo(image->getInternalFormat()); + + // We can only handle full updates for depth-stencil textures, so to avoid complications + // disable them entirely. + if (internalFormat.depthBits > 0 || internalFormat.stencilBits > 0) + { + return false; + } + + // TODO(jmadill): Handle compressed internal formats + return (mTexStorage && !internalFormat.compressed); +} + +angle::Result TextureD3D::setImageImpl(const gl::Context *context, + const gl::ImageIndex &index, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + ptrdiff_t layerOffset) +{ + ImageD3D *image = getImage(index); + ASSERT(image); + + // No-op + if (image->getWidth() == 0 || image->getHeight() == 0 || image->getDepth() == 0) + { + return angle::Result::Continue; + } + + // We no longer need the "GLenum format" parameter to TexImage to determine what data format + // "pixels" contains. From our image internal format we know how many channels to expect, and + // "type" gives the format of pixel's components. + const uint8_t *pixelData = nullptr; + ANGLE_TRY(GetUnpackPointer(context, unpack, unpackBuffer, pixels, layerOffset, &pixelData)); + + if (pixelData != nullptr) + { + if (shouldUseSetData(image)) + { + ANGLE_TRY( + mTexStorage->setData(context, index, image, nullptr, type, unpack, pixelData)); + } + else + { + gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), + image->getDepth()); + ANGLE_TRY(image->loadData(context, fullImageArea, unpack, type, pixelData, + index.usesTex3D())); + } + + mDirtyImages = true; + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::subImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + ptrdiff_t layerOffset) +{ + // CPU readback & copy where direct GPU copy is not supported + const uint8_t *pixelData = nullptr; + ANGLE_TRY(GetUnpackPointer(context, unpack, unpackBuffer, pixels, layerOffset, &pixelData)); + + if (pixelData != nullptr) + { + ImageD3D *image = getImage(index); + ASSERT(image); + + if (shouldUseSetData(image)) + { + return mTexStorage->setData(context, index, image, &area, type, unpack, pixelData); + } + + ANGLE_TRY(image->loadData(context, area, unpack, type, pixelData, index.usesTex3D())); + ANGLE_TRY(commitRegion(context, index, area)); + mDirtyImages = true; + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::setCompressedImageImpl(const gl::Context *context, + const gl::ImageIndex &index, + const gl::PixelUnpackState &unpack, + const uint8_t *pixels, + ptrdiff_t layerOffset) +{ + ImageD3D *image = getImage(index); + ASSERT(image); + + if (image->getWidth() == 0 || image->getHeight() == 0 || image->getDepth() == 0) + { + return angle::Result::Continue; + } + + // We no longer need the "GLenum format" parameter to TexImage to determine what data format + // "pixels" contains. From our image internal format we know how many channels to expect, and + // "type" gives the format of pixel's components. + const uint8_t *pixelData = nullptr; + gl::Buffer *unpackBuffer = context->getState().getTargetBuffer(gl::BufferBinding::PixelUnpack); + ANGLE_TRY(GetUnpackPointer(context, unpack, unpackBuffer, pixels, layerOffset, &pixelData)); + + if (pixelData != nullptr) + { + gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth()); + ANGLE_TRY(image->loadCompressedData(context, fullImageArea, pixelData)); + + mDirtyImages = true; + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::subImageCompressed(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + const uint8_t *pixels, + ptrdiff_t layerOffset) +{ + const uint8_t *pixelData = nullptr; + gl::Buffer *unpackBuffer = context->getState().getTargetBuffer(gl::BufferBinding::PixelUnpack); + ANGLE_TRY(GetUnpackPointer(context, unpack, unpackBuffer, pixels, layerOffset, &pixelData)); + + if (pixelData != nullptr) + { + ImageD3D *image = getImage(index); + ASSERT(image); + + ANGLE_TRY(image->loadCompressedData(context, area, pixelData)); + + mDirtyImages = true; + } + + return angle::Result::Continue; +} + +bool TextureD3D::isFastUnpackable(const gl::Buffer *unpackBuffer, + const gl::PixelUnpackState &unpack, + GLenum sizedInternalFormat) +{ + return unpackBuffer != nullptr && unpack.skipRows == 0 && unpack.skipPixels == 0 && + unpack.imageHeight == 0 && unpack.skipImages == 0 && + mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat); +} + +angle::Result TextureD3D::fastUnpackPixels(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + const gl::Box &destArea, + GLenum sizedInternalFormat, + GLenum type, + RenderTargetD3D *destRenderTarget) +{ + bool check = (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 || + unpack.skipImages != 0); + ANGLE_CHECK(GetImplAs<ContextD3D>(context), !check, + "Unimplemented pixel store parameters in fastUnpackPixels", GL_INVALID_OPERATION); + + // No-op + if (destArea.width <= 0 && destArea.height <= 0 && destArea.depth <= 0) + { + return angle::Result::Continue; + } + + // In order to perform the fast copy through the shader, we must have the right format, and be + // able to create a render target. + ASSERT(mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat)); + + uintptr_t offset = reinterpret_cast<uintptr_t>(pixels); + + ANGLE_TRY(mRenderer->fastCopyBufferToTexture( + context, unpack, unpackBuffer, static_cast<unsigned int>(offset), destRenderTarget, + sizedInternalFormat, type, destArea)); + + return angle::Result::Continue; +} + +GLint TextureD3D::creationLevels(GLsizei width, GLsizei height, GLsizei depth) const +{ + if ((gl::isPow2(width) && gl::isPow2(height) && gl::isPow2(depth)) || + mRenderer->getNativeExtensions().textureNpotOES) + { + // Maximum number of levels + return gl::log2(std::max(std::max(width, height), depth)) + 1; + } + else + { + // OpenGL ES 2.0 without GL_OES_texture_npot does not permit NPOT mipmaps. + return 1; + } +} + +TextureStorage *TextureD3D::getStorage() +{ + ASSERT(mTexStorage); + return mTexStorage; +} + +ImageD3D *TextureD3D::getBaseLevelImage() const +{ + if (mBaseLevel >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + return nullptr; + } + return getImage(getImageIndex(mBaseLevel, 0)); +} + +angle::Result TextureD3D::setImageExternal(const gl::Context *context, + gl::TextureType type, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc) +{ + // Only external images can accept external textures + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D::generateMipmap(const gl::Context *context) +{ + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + ASSERT(maxLevel > baseLevel); // Should be checked before calling this. + + if (mTexStorage && mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // Switch to using the mipmapped texture. + TextureStorage *textureStorageEXT = nullptr; + ANGLE_TRY(getNativeTexture(context, &textureStorageEXT)); + ANGLE_TRY(textureStorageEXT->useLevelZeroWorkaroundTexture(context, false)); + } + + // Set up proper mipmap chain in our Image array. + ANGLE_TRY(initMipmapImages(context)); + + if (mTexStorage && mTexStorage->supportsNativeMipmapFunction()) + { + ANGLE_TRY(updateStorage(context)); + + // Generate the mipmap chain using the ad-hoc DirectX function. + ANGLE_TRY(mRenderer->generateMipmapUsingD3D(context, mTexStorage, mState)); + } + else + { + // Generate the mipmap chain, one level at a time. + ANGLE_TRY(generateMipmapUsingImages(context, maxLevel)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::generateMipmapUsingImages(const gl::Context *context, + const GLuint maxLevel) +{ + // We know that all layers have the same dimension, for the texture to be complete + GLint layerCount = static_cast<GLint>(getLayerCount(mBaseLevel)); + + if (mTexStorage && !mTexStorage->isRenderTarget() && + canCreateRenderTargetForImage(getImageIndex(mBaseLevel, 0)) && + mRenderer->getRendererClass() == RENDERER_D3D11) + { + if (!mRenderer->getFeatures().setDataFasterThanImageUpload.enabled) + { + ANGLE_TRY(updateStorage(context)); + } + ANGLE_TRY(ensureRenderTarget(context)); + } + else if (couldUseSetData() && mTexStorage) + { + // When making mipmaps with the setData workaround enabled, the texture storage has + // the image data already. For non-render-target storage, we have to pull it out into + // an image layer. + if (!mTexStorage->isRenderTarget()) + { + // Copy from the storage mip 0 to Image mip 0 + for (GLint layer = 0; layer < layerCount; ++layer) + { + gl::ImageIndex srcIndex = getImageIndex(mBaseLevel, layer); + + ImageD3D *image = getImage(srcIndex); + ANGLE_TRY(image->copyFromTexStorage(context, srcIndex, mTexStorage)); + } + } + else + { + ANGLE_TRY(updateStorage(context)); + } + } + + // TODO: Decouple this from zeroMaxLodWorkaround. This is a 9_3 restriction, unrelated to + // zeroMaxLodWorkaround. The restriction is because Feature Level 9_3 can't create SRVs on + // individual levels of the texture. As a result, even if the storage is a rendertarget, we + // can't use the GPU to generate the mipmaps without further work. The D3D9 renderer works + // around this by copying each level of the texture into its own single-layer GPU texture (in + // Blit9::boxFilter). Feature Level 9_3 could do something similar, or it could continue to use + // CPU-side mipmap generation, or something else. + bool renderableStorage = (mTexStorage && mTexStorage->isRenderTarget() && + !(mRenderer->getFeatures().zeroMaxLodWorkaround.enabled)); + if (renderableStorage) + { + ANGLE_TRY(updateStorage(context)); + } + + for (GLint layer = 0; layer < layerCount; ++layer) + { + for (GLuint mip = mBaseLevel + 1; mip <= maxLevel; ++mip) + { + ASSERT(getLayerCount(mip) == layerCount); + + gl::ImageIndex sourceIndex = getImageIndex(mip - 1, layer); + gl::ImageIndex destIndex = getImageIndex(mip, layer); + + if (renderableStorage) + { + // GPU-side mipmapping + ANGLE_TRY(mTexStorage->generateMipmap(context, sourceIndex, destIndex)); + } + else + { + // CPU-side mipmapping + ANGLE_TRY( + mRenderer->generateMipmap(context, getImage(destIndex), getImage(sourceIndex))); + } + } + } + + mDirtyImages = !renderableStorage; + + if (mTexStorage && mDirtyImages) + { + ANGLE_TRY(updateStorage(context)); + } + + return angle::Result::Continue; +} + +bool TextureD3D::isBaseImageZeroSize() const +{ + ImageD3D *baseImage = getBaseLevelImage(); + + if (!baseImage || baseImage->getWidth() <= 0 || baseImage->getHeight() <= 0) + { + return true; + } + + if (baseImage->getType() == gl::TextureType::_3D && baseImage->getDepth() <= 0) + { + return true; + } + + if (baseImage->getType() == gl::TextureType::_2DArray && getLayerCount(getBaseLevel()) <= 0) + { + return true; + } + + return false; +} + +angle::Result TextureD3D::ensureBindFlags(const gl::Context *context, BindFlags bindFlags) +{ + ANGLE_TRY(initializeStorage(context, bindFlags)); + + // initializeStorage can fail with NoError if the texture is not complete. This is not + // an error for incomplete sampling, but it is a big problem for rendering. + if (!mTexStorage) + { + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Stop; + } + + if (!isBaseImageZeroSize()) + { + ASSERT(mTexStorage); + if ((bindFlags.renderTarget && !mTexStorage->isRenderTarget()) || + (bindFlags.unorderedAccess && !mTexStorage->isUnorderedAccess())) + { + TexStoragePointer newRenderTargetStorage; + ANGLE_TRY(createCompleteStorage(context, bindFlags, &newRenderTargetStorage)); + + ANGLE_TRY(mTexStorage->copyToStorage(context, newRenderTargetStorage.get())); + ANGLE_TRY(setCompleteTexStorage(context, newRenderTargetStorage.get())); + newRenderTargetStorage.release(); + // If this texture is used in compute shader, we should invalidate this texture so that + // the UAV/SRV is rebound again with this new texture storage in next dispatch call. + mTexStorage->invalidateTextures(); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::ensureRenderTarget(const gl::Context *context) +{ + return ensureBindFlags(context, BindFlags::RenderTarget()); +} + +angle::Result TextureD3D::ensureUnorderedAccess(const gl::Context *context) +{ + return ensureBindFlags(context, BindFlags::UnorderedAccess()); +} + +bool TextureD3D::canCreateRenderTargetForImage(const gl::ImageIndex &index) const +{ + if (index.getType() == gl::TextureType::_2DMultisample || + index.getType() == gl::TextureType::_2DMultisampleArray) + { + ASSERT(index.getType() != gl::TextureType::_2DMultisampleArray || index.hasLayer()); + return true; + } + + ImageD3D *image = getImage(index); + ASSERT(image); + bool levelsComplete = (isImageComplete(index) && isImageComplete(getImageIndex(0, 0))); + return (image->isRenderableFormat() && levelsComplete); +} + +angle::Result TextureD3D::commitRegion(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box ®ion) +{ + if (mTexStorage) + { + ASSERT(isValidIndex(index)); + ImageD3D *image = getImage(index); + ANGLE_TRY(image->copyToStorage(context, mTexStorage, index, region)); + image->markClean(); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) +{ + RenderTargetD3D *rtD3D = nullptr; + ANGLE_TRY(getRenderTarget(context, imageIndex, samples, &rtD3D)); + *rtOut = static_cast<FramebufferAttachmentRenderTarget *>(rtD3D); + return angle::Result::Continue; +} + +angle::Result TextureD3D::setBaseLevel(const gl::Context *context, GLuint baseLevel) +{ + const int oldStorageWidth = std::max(1, getLevelZeroWidth()); + const int oldStorageHeight = std::max(1, getLevelZeroHeight()); + const int oldStorageDepth = std::max(1, getLevelZeroDepth()); + const int oldStorageFormat = getBaseLevelInternalFormat(); + mBaseLevel = baseLevel; + + // When the base level changes, the texture storage might not be valid anymore, since it could + // have been created based on the dimensions of the previous specified level range. + const int newStorageWidth = std::max(1, getLevelZeroWidth()); + const int newStorageHeight = std::max(1, getLevelZeroHeight()); + const int newStorageDepth = std::max(1, getLevelZeroDepth()); + const int newStorageFormat = getBaseLevelInternalFormat(); + if (mTexStorage && + (newStorageWidth != oldStorageWidth || newStorageHeight != oldStorageHeight || + newStorageDepth != oldStorageDepth || newStorageFormat != oldStorageFormat)) + { + markAllImagesDirty(); + + // Iterate over all images, and backup the content if it's been used as a render target. The + // D3D11 backend can automatically restore images on storage destroy, but it only works for + // images that have been associated with the texture storage before, which is insufficient + // here. + if (mTexStorage->isRenderTarget()) + { + gl::ImageIndexIterator iterator = imageIterator(); + while (iterator.hasNext()) + { + const gl::ImageIndex index = iterator.next(); + const GLsizei samples = getRenderToTextureSamples(); + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(mTexStorage->findRenderTarget(context, index, samples, &renderTarget)); + if (renderTarget) + { + ANGLE_TRY(getImage(index)->copyFromTexStorage(context, index, mTexStorage)); + } + } + } + + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D::onLabelUpdate(const gl::Context *context) +{ + if (mTexStorage) + { + mTexStorage->setLabel(mState.getLabel()); + } + return angle::Result::Continue; +} + +angle::Result TextureD3D::syncState(const gl::Context *context, + const gl::Texture::DirtyBits &dirtyBits, + gl::Command source) +{ + // This could be improved using dirty bits. + return angle::Result::Continue; +} + +angle::Result TextureD3D::releaseTexStorage(const gl::Context *context, + const gl::TexLevelMask ©StorageToImagesMask) +{ + if (!mTexStorage) + { + return angle::Result::Continue; + } + + if (mTexStorage->isRenderTarget()) + { + const GLenum storageFormat = getBaseLevelInternalFormat(); + const size_t storageLevels = mTexStorage->getLevelCount(); + + gl::ImageIndexIterator iterator = imageIterator(); + while (iterator.hasNext()) + { + const gl::ImageIndex index = iterator.next(); + ImageD3D *image = getImage(index); + const int storageWidth = std::max(1, getLevelZeroWidth() >> index.getLevelIndex()); + const int storageHeight = std::max(1, getLevelZeroHeight() >> index.getLevelIndex()); + if (image && isImageComplete(index) && image->getWidth() == storageWidth && + image->getHeight() == storageHeight && + image->getInternalFormat() == storageFormat && + index.getLevelIndex() < static_cast<int>(storageLevels) && + copyStorageToImagesMask[index.getLevelIndex()]) + { + ANGLE_TRY(image->copyFromTexStorage(context, index, mTexStorage)); + } + } + } + + onStateChange(angle::SubjectMessage::StorageReleased); + + auto err = mTexStorage->onDestroy(context); + SafeDelete(mTexStorage); + return err; +} + +void TextureD3D::onDestroy(const gl::Context *context) +{ + (void)releaseTexStorage(context, gl::TexLevelMask()); +} + +angle::Result TextureD3D::initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) +{ + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + gl::ImageIndex index = imageIndex; + + // Special case for D3D11 3D textures. We can't create render targets for individual layers of a + // 3D texture, so force the clear to the entire mip. There shouldn't ever be a case where we + // would lose existing data. + if (index.getType() == gl::TextureType::_3D) + { + index = gl::ImageIndex::Make3D(index.getLevelIndex(), gl::ImageIndex::kEntireLevel); + } + else if (index.getType() == gl::TextureType::_2DArray && !index.hasLayer()) + { + std::array<GLint, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS> tempLayerCounts; + + GLint levelIndex = index.getLevelIndex(); + tempLayerCounts[levelIndex] = getLayerCount(levelIndex); + gl::ImageIndexIterator iterator = + gl::ImageIndexIterator::Make2DArray(levelIndex, levelIndex + 1, tempLayerCounts.data()); + while (iterator.hasNext()) + { + ANGLE_TRY(initializeContents(context, GL_NONE, iterator.next())); + } + return angle::Result::Continue; + } + else if (index.getType() == gl::TextureType::_2DMultisampleArray && !index.hasLayer()) + { + std::array<GLint, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS> tempLayerCounts; + + ASSERT(index.getLevelIndex() == 0); + tempLayerCounts[0] = getLayerCount(0); + gl::ImageIndexIterator iterator = + gl::ImageIndexIterator::Make2DMultisampleArray(tempLayerCounts.data()); + while (iterator.hasNext()) + { + ANGLE_TRY(initializeContents(context, GL_NONE, iterator.next())); + } + return angle::Result::Continue; + } + + // Force image clean. + ImageD3D *image = getImage(index); + if (image) + { + image->markClean(); + } + + // Fast path: can use a render target clear. + // We don't use the fast path with the zero max lod workaround because it would introduce a race + // between the rendertarget and the staging images. + const angle::FeaturesD3D &features = mRenderer->getFeatures(); + bool shouldUseClear = (image == nullptr); + if (canCreateRenderTargetForImage(index) && !features.zeroMaxLodWorkaround.enabled && + (shouldUseClear || features.allowClearForRobustResourceInit.enabled)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(mTexStorage); + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(mTexStorage->getRenderTarget(context, index, 0, &renderTarget)); + ANGLE_TRY(mRenderer->initRenderTarget(context, renderTarget)); + + // Force image clean again, the texture storage may have been re-created and the image used. + if (image) + { + image->markClean(); + } + + return angle::Result::Continue; + } + + ASSERT(image != nullptr); + + // Slow path: non-renderable texture or the texture levels aren't set up. + const auto &formatInfo = gl::GetSizedInternalFormatInfo(image->getInternalFormat()); + + GLuint imageBytes = 0; + ANGLE_CHECK_GL_MATH(contextD3D, formatInfo.computeRowPitch(formatInfo.type, image->getWidth(), + 1, 0, &imageBytes)); + imageBytes *= image->getHeight() * image->getDepth(); + + gl::PixelUnpackState zeroDataUnpackState; + zeroDataUnpackState.alignment = 1; + + angle::MemoryBuffer *zeroBuffer = nullptr; + ANGLE_CHECK_GL_ALLOC(contextD3D, context->getZeroFilledBuffer(imageBytes, &zeroBuffer)); + + if (shouldUseSetData(image)) + { + ANGLE_TRY(mTexStorage->setData(context, index, image, nullptr, formatInfo.type, + zeroDataUnpackState, zeroBuffer->data())); + } + else + { + gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth()); + ANGLE_TRY(image->loadData(context, fullImageArea, zeroDataUnpackState, formatInfo.type, + zeroBuffer->data(), false)); + + // Force an update to the tex storage so we avoid problems with subImage and dirty regions. + if (mTexStorage) + { + ANGLE_TRY(commitRegion(context, index, fullImageArea)); + image->markClean(); + } + else + { + mDirtyImages = true; + } + } + return angle::Result::Continue; +} + +GLsizei TextureD3D::getRenderToTextureSamples() +{ + if (mTexStorage) + { + return mTexStorage->getRenderToTextureSamples(); + } + return 0; +} + +void TextureD3D::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) +{ + onStateChange(message); +} + +TextureD3D_2D::TextureD3D_2D(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3D(state, renderer) +{ + mEGLImageTarget = false; + for (auto &image : mImageArray) + { + image.reset(renderer->createImage()); + } +} + +void TextureD3D_2D::onDestroy(const gl::Context *context) +{ + // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage + // for some of their data. If TextureStorage is deleted before the Images, then their data will + // be wastefully copied back from the GPU before we delete the Images. + for (auto &image : mImageArray) + { + image.reset(); + } + return TextureD3D::onDestroy(context); +} + +TextureD3D_2D::~TextureD3D_2D() {} + +ImageD3D *TextureD3D_2D::getImage(int level, int layer) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(layer == 0); + return mImageArray[level].get(); +} + +ImageD3D *TextureD3D_2D::getImage(const gl::ImageIndex &index) const +{ + ASSERT(index.getLevelIndex() < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(!index.hasLayer()); + ASSERT(index.getType() == gl::TextureType::_2D || + index.getType() == gl::TextureType::VideoImage); + return mImageArray[index.getLevelIndex()].get(); +} + +GLsizei TextureD3D_2D::getLayerCount(int level) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + return 1; +} + +GLsizei TextureD3D_2D::getWidth(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getWidth(); + else + return 0; +} + +GLsizei TextureD3D_2D::getHeight(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getHeight(); + else + return 0; +} + +GLenum TextureD3D_2D::getInternalFormat(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getInternalFormat(); + else + return GL_NONE; +} + +bool TextureD3D_2D::isDepth(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0; +} + +bool TextureD3D_2D::isSRGB(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).colorEncoding == GL_SRGB; +} + +angle::Result TextureD3D_2D::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT((index.getTarget() == gl::TextureTarget::_2D || + index.getTarget() == gl::TextureTarget::VideoImage) && + size.depth == 1); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + + bool fastUnpacked = false; + + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + size, false)); + + // Attempt a fast gpu copy of the pixel data to the surface + if (mTexStorage) + { + ANGLE_TRY(mTexStorage->releaseMultisampledTexStorageForLevel(index.getLevelIndex())); + } + if (isFastUnpackable(unpackBuffer, unpack, internalFormatInfo.sizedInternalFormat) && + isLevelComplete(index.getLevelIndex())) + { + // Will try to create RT storage if it does not exist + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, index, getRenderToTextureSamples(), &destRenderTarget)); + + gl::Box destArea(0, 0, 0, getWidth(index.getLevelIndex()), getHeight(index.getLevelIndex()), + 1); + + ANGLE_TRY(fastUnpackPixels(context, unpack, unpackBuffer, pixels, destArea, + internalFormatInfo.sizedInternalFormat, type, destRenderTarget)); + + // Ensure we don't overwrite our newly initialized data + mImageArray[index.getLevelIndex()]->markClean(); + + fastUnpacked = true; + } + + if (!fastUnpacked) + { + ANGLE_TRY(setImageImpl(context, index, type, unpack, unpackBuffer, pixels, 0)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D && area.depth == 1 && area.z == 0); + + GLenum mipFormat = getInternalFormat(index.getLevelIndex()); + if (mTexStorage) + { + ANGLE_TRY(mTexStorage->releaseMultisampledTexStorageForLevel(index.getLevelIndex())); + } + if (isFastUnpackable(unpackBuffer, unpack, mipFormat) && isLevelComplete(index.getLevelIndex())) + { + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, index, getRenderToTextureSamples(), &renderTarget)); + ASSERT(!mImageArray[index.getLevelIndex()]->isDirty()); + + return fastUnpackPixels(context, unpack, unpackBuffer, pixels, area, mipFormat, type, + renderTarget); + } + else + { + return TextureD3D::subImage(context, index, area, format, type, unpack, unpackBuffer, + pixels, 0); + } +} + +angle::Result TextureD3D_2D::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D && size.depth == 1); + + // compressed formats don't have separate sized internal formats-- we can just use the + // compressed format directly + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormat, size, false)); + + return setCompressedImageImpl(context, index, unpack, pixels, 0); +} + +angle::Result TextureD3D_2D::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D && area.depth == 1 && area.z == 0); + ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0)); + + return commitRegion(context, index, area); +} + +angle::Result TextureD3D_2D::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D); + + const gl::InternalFormat &internalFormatInfo = + gl::GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE); + gl::Extents sourceExtents(sourceArea.width, sourceArea.height, 1); + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + sourceExtents, false)); + + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + + // Does the read area extend beyond the framebuffer? + bool outside = sourceArea.x < 0 || sourceArea.y < 0 || + sourceArea.x + sourceArea.width > fbSize.width || + sourceArea.y + sourceArea.height > fbSize.height; + + // WebGL requires that pixels that would be outside the framebuffer are treated as zero values, + // so clear the mip level to 0 prior to making the copy if any pixel would be sampled outside. + // Same thing for robust resource init. + if (outside && (context->isWebGL() || context->isRobustResourceInitEnabled())) + { + ANGLE_TRY(initializeContents(context, GL_NONE, index)); + } + + gl::Rectangle clippedArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + // Empty source area, nothing to do. + return angle::Result::Continue; + } + + gl::Offset destOffset(clippedArea.x - sourceArea.x, clippedArea.y - sourceArea.y, 0); + + // If the zero max LOD workaround is active, then we can't sample from individual layers of the + // framebuffer in shaders, so we should use the non-rendering copy path. + if (!canCreateRenderTargetForImage(index) || + mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(mImageArray[index.getLevelIndex()]->copyFromFramebuffer(context, destOffset, + clippedArea, source)); + mDirtyImages = true; + } + else + { + ANGLE_TRY(ensureRenderTarget(context)); + + if (clippedArea.width != 0 && clippedArea.height != 0 && + isValidLevel(index.getLevelIndex())) + { + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyImage2D(context, source, clippedArea, internalFormat, + destOffset, mTexStorage, index.getLevelIndex())); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D && destOffset.z == 0); + + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + gl::Rectangle clippedArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + return angle::Result::Continue; + } + const gl::Offset clippedOffset(destOffset.x + clippedArea.x - sourceArea.x, + destOffset.y + clippedArea.y - sourceArea.y, 0); + + // can only make our texture storage to a render target if level 0 is defined (with a width & + // height) and the current level we're copying to is defined (with appropriate format, width & + // height) + + // If the zero max LOD workaround is active, then we can't sample from individual layers of the + // framebuffer in shaders, so we should use the non-rendering copy path. + if (!canCreateRenderTargetForImage(index) || + mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(mImageArray[index.getLevelIndex()]->copyFromFramebuffer(context, clippedOffset, + clippedArea, source)); + mDirtyImages = true; + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + } + else + { + ANGLE_TRY(ensureRenderTarget(context)); + + if (isValidLevel(index.getLevelIndex())) + { + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyImage2D(context, source, clippedArea, + gl::GetUnsizedFormat(getBaseLevelInternalFormat()), + clippedOffset, mTexStorage, index.getLevelIndex())); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D); + + gl::TextureType sourceType = source->getType(); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + gl::Extents size( + static_cast<int>(source->getWidth(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + static_cast<int>(source->getHeight(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + 1); + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + size, false)); + + gl::Box sourceBox(0, 0, 0, size.width, size.height, 1); + gl::Offset destOffset(0, 0, 0); + + if (!isSRGB(index.getLevelIndex()) && canCreateRenderTargetForImage(index)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(index.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(sourceLevel); + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, index, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(destOffset, size); + ANGLE_TRY(commitRegion(context, index, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2D); + + if (!isSRGB(index.getLevelIndex()) && canCreateRenderTargetForImage(index)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(index.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + + const gl::InternalFormat &internalFormatInfo = + gl::GetSizedInternalFormatInfo(getInternalFormat(index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(sourceLevel); + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, index, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(destOffset.x, destOffset.y, 0, sourceBox.width, sourceBox.height, 1); + ANGLE_TRY(commitRegion(context, index, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::copyCompressedTexture(const gl::Context *context, + const gl::Texture *source) +{ + gl::TextureTarget sourceTarget = NonCubeTextureTypeToTarget(source->getType()); + GLint sourceLevel = 0; + + GLint destLevel = 0; + + GLenum sizedInternalFormat = + source->getFormat(sourceTarget, sourceLevel).info->sizedInternalFormat; + gl::Extents size(static_cast<int>(source->getWidth(sourceTarget, sourceLevel)), + static_cast<int>(source->getHeight(sourceTarget, sourceLevel)), 1); + ANGLE_TRY(redefineImage(context, destLevel, sizedInternalFormat, size, false)); + + ANGLE_TRY(initializeStorage(context, BindFlags())); + ASSERT(mTexStorage); + + ANGLE_TRY( + mRenderer->copyCompressedTexture(context, source, sourceLevel, mTexStorage, destLevel)); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) +{ + ASSERT(type == gl::TextureType::_2D && size.depth == 1); + + for (size_t level = 0; level < levels; level++) + { + gl::Extents levelSize(std::max(1, size.width >> level), std::max(1, size.height >> level), + 1); + ANGLE_TRY(redefineImage(context, level, internalFormat, levelSize, true)); + } + + for (size_t level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + ANGLE_TRY(redefineImage(context, level, GL_NONE, gl::Extents(0, 0, 1), true)); + } + + // TODO(geofflang): Verify storage creation had no errors + BindFlags flags; + flags.renderTarget = IsRenderTargetUsage(mState.getUsage()); + TexStoragePointer storage = { + mRenderer->createTextureStorage2D(internalFormat, flags, size.width, size.height, + static_cast<int>(levels), mState.getLabel(), false), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ANGLE_TRY(updateStorage(context)); + + mImmutable = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::bindTexImage(const gl::Context *context, egl::Surface *surface) +{ + GLenum internalformat = surface->getConfig()->renderTargetFormat; + + gl::Extents size(surface->getWidth(), surface->getHeight(), 1); + ANGLE_TRY(redefineImage(context, 0, internalformat, size, true)); + + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + + SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface); + ASSERT(surfaceD3D); + + mTexStorage = mRenderer->createTextureStorage2D(surfaceD3D->getSwapChain(), mState.getLabel()); + mEGLImageTarget = false; + + mDirtyImages = false; + mImageArray[0]->markClean(); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::releaseTexImage(const gl::Context *context) +{ + if (mTexStorage) + { + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + } + + for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + ANGLE_TRY(redefineImage(context, i, GL_NONE, gl::Extents(0, 0, 1), true)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + EGLImageD3D *eglImaged3d = GetImplAs<EGLImageD3D>(image); + + // Set the properties of the base mip level from the EGL image + const auto &format = image->getFormat(); + gl::Extents size(static_cast<int>(image->getWidth()), static_cast<int>(image->getHeight()), 1); + ANGLE_TRY(redefineImage(context, 0, format.info->sizedInternalFormat, size, true)); + + // Clear all other images. + for (size_t level = 1; level < mImageArray.size(); level++) + { + ANGLE_TRY(redefineImage(context, level, GL_NONE, gl::Extents(0, 0, 1), true)); + } + + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + mImageArray[0]->markClean(); + + // Pass in the RenderTargetD3D here: createTextureStorage can't generate an error. + RenderTargetD3D *renderTargetD3D = nullptr; + ANGLE_TRY(eglImaged3d->getRenderTarget(context, &renderTargetD3D)); + + mTexStorage = + mRenderer->createTextureStorageEGLImage(eglImaged3d, renderTargetD3D, mState.getLabel()); + mEGLImageTarget = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::initMipmapImages(const gl::Context *context) +{ + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + // Purge array levels baseLevel + 1 through q and reset them to represent the generated mipmap + // levels. + for (GLuint level = baseLevel + 1; level <= maxLevel; level++) + { + gl::Extents levelSize(std::max(getLevelZeroWidth() >> level, 1), + std::max(getLevelZeroHeight() >> level, 1), 1); + + ANGLE_TRY(redefineImage(context, level, getBaseLevelInternalFormat(), levelSize, false)); + } + + // We should be mip-complete now so generate the storage. + ANGLE_TRY(initializeStorage(context, BindFlags::RenderTarget())); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +bool TextureD3D_2D::isValidLevel(int level) const +{ + return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : false); +} + +bool TextureD3D_2D::isLevelComplete(int level) const +{ + if (isImmutable()) + { + return true; + } + + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + + if (width <= 0 || height <= 0) + { + return false; + } + + // The base image level is complete if the width and height are positive + if (level == static_cast<int>(getBaseLevel())) + { + return true; + } + + ASSERT(level >= 0 && level <= static_cast<int>(mImageArray.size()) && + mImageArray[level] != nullptr); + ImageD3D *image = mImageArray[level].get(); + + if (image->getInternalFormat() != getBaseLevelInternalFormat()) + { + return false; + } + + if (image->getWidth() != std::max(1, width >> level)) + { + return false; + } + + if (image->getHeight() != std::max(1, height >> level)) + { + return false; + } + + return true; +} + +bool TextureD3D_2D::isImageComplete(const gl::ImageIndex &index) const +{ + return isLevelComplete(index.getLevelIndex()); +} + +// Constructs a native texture resource from the texture images +angle::Result TextureD3D_2D::initializeStorage(const gl::Context *context, BindFlags bindFlags) +{ + // Only initialize the first time this texture is used as a render target or shader resource + if (mTexStorage) + { + return angle::Result::Continue; + } + + // do not attempt to create storage for nonexistant data + if (!isLevelComplete(getBaseLevel())) + { + return angle::Result::Continue; + } + + bindFlags.renderTarget |= IsRenderTargetUsage(mState.getUsage()); + + TexStoragePointer storage; + ANGLE_TRY(createCompleteStorage(context, bindFlags, &storage)); + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ASSERT(mTexStorage); + + // flush image data to the storage + ANGLE_TRY(updateStorage(context)); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + GLenum internalFormat = getBaseLevelInternalFormat(); + + ASSERT(width > 0 && height > 0); + + // use existing storage level count, when previously specified by TexStorage*D + GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1)); + + bool hintLevelZeroOnly = false; + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // If any of the CPU images (levels >= 1) are dirty, then the textureStorage2D should use + // the mipped texture to begin with. Otherwise, it should use the level-zero-only texture. + hintLevelZeroOnly = true; + for (int level = 1; level < levels && hintLevelZeroOnly; level++) + { + hintLevelZeroOnly = !(mImageArray[level]->isDirty() && isLevelComplete(level)); + } + } + + // TODO(geofflang): Determine if the texture creation succeeded + *outStorage = {mRenderer->createTextureStorage2D(internalFormat, bindFlags, width, height, + levels, mState.getLabel(), hintLevelZeroOnly), + context}; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + if (newCompleteTexStorage && newCompleteTexStorage->isManaged()) + { + for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++) + { + ANGLE_TRY( + mImageArray[level]->setManagedSurface2D(context, newCompleteTexStorage, level)); + } + } + + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + + mDirtyImages = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::updateStorage(const gl::Context *context) +{ + if (!mDirtyImages) + { + return angle::Result::Continue; + } + + ASSERT(mTexStorage != nullptr); + GLint storageLevels = mTexStorage->getLevelCount(); + for (int level = 0; level < storageLevels; level++) + { + if (mImageArray[level]->isDirty() && isLevelComplete(level)) + { + ANGLE_TRY(updateStorageLevel(context, level)); + } + } + + mDirtyImages = false; + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::updateStorageLevel(const gl::Context *context, int level) +{ + ASSERT(level <= static_cast<int>(mImageArray.size()) && mImageArray[level] != nullptr); + ASSERT(isLevelComplete(level)); + + if (mImageArray[level]->isDirty()) + { + gl::ImageIndex index = gl::ImageIndex::Make2D(level); + gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1); + ANGLE_TRY(commitRegion(context, index, region)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2D::redefineImage(const gl::Context *context, + size_t level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + ASSERT(size.depth == 1); + + // If there currently is a corresponding storage texture image, it has these parameters + const int storageWidth = std::max(1, getLevelZeroWidth() >> level); + const int storageHeight = std::max(1, getLevelZeroHeight() >> level); + const GLenum storageFormat = getBaseLevelInternalFormat(); + + if (mTexStorage) + { + const size_t storageLevels = mTexStorage->getLevelCount(); + + // If the storage was from an EGL image, copy it back into local images to preserve it + // while orphaning + if (level != 0 && mEGLImageTarget) + { + ANGLE_TRY(mImageArray[0]->copyFromTexStorage(context, gl::ImageIndex::Make2D(0), + mTexStorage)); + } + + if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth || + size.height != storageHeight || internalformat != storageFormat || + mEGLImageTarget) // Discard mismatched storage + { + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + copyImageMask.set(level, false); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + markAllImagesDirty(); + } + } + + mImageArray[level]->redefine(gl::TextureType::_2D, internalformat, size, forceRelease); + mDirtyImages = mDirtyImages || mImageArray[level]->isDirty(); + + // Can't be an EGL image target after being redefined + mEGLImageTarget = false; + + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_2D::imageIterator() const +{ + return gl::ImageIndexIterator::Make2D(0, mTexStorage->getLevelCount()); +} + +gl::ImageIndex TextureD3D_2D::getImageIndex(GLint mip, GLint /*layer*/) const +{ + // "layer" does not apply to 2D Textures. + return gl::ImageIndex::Make2D(mip); +} + +bool TextureD3D_2D::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::_2D && index.getLevelIndex() >= 0 && + index.getLevelIndex() < mTexStorage->getLevelCount()); +} + +void TextureD3D_2D::markAllImagesDirty() +{ + for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + mImageArray[i]->markDirty(); + } + mDirtyImages = true; +} + +TextureD3D_Cube::TextureD3D_Cube(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3D(state, renderer) +{ + for (auto &face : mImageArray) + { + for (auto &image : face) + { + image.reset(renderer->createImage()); + } + } +} + +void TextureD3D_Cube::onDestroy(const gl::Context *context) +{ + // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage + // for some of their data. If TextureStorage is deleted before the Images, then their data will + // be wastefully copied back from the GPU before we delete the Images. + for (auto &face : mImageArray) + { + for (auto &image : face) + { + image.reset(); + } + } + return TextureD3D::onDestroy(context); +} + +TextureD3D_Cube::~TextureD3D_Cube() {} + +ImageD3D *TextureD3D_Cube::getImage(int level, int layer) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(layer >= 0 && static_cast<size_t>(layer) < gl::kCubeFaceCount); + return mImageArray[layer][level].get(); +} + +ImageD3D *TextureD3D_Cube::getImage(const gl::ImageIndex &index) const +{ + ASSERT(index.getLevelIndex() < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(gl::IsCubeMapFaceTarget(index.getTarget())); + return mImageArray[index.cubeMapFaceIndex()][index.getLevelIndex()].get(); +} + +GLsizei TextureD3D_Cube::getLayerCount(int level) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + return gl::kCubeFaceCount; +} + +GLenum TextureD3D_Cube::getInternalFormat(GLint level, GLint layer) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[layer][level]->getInternalFormat(); + else + return GL_NONE; +} + +bool TextureD3D_Cube::isDepth(GLint level, GLint layer) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level, layer)).depthBits > 0; +} + +bool TextureD3D_Cube::isSRGB(GLint level, GLint layer) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level, layer)).colorEncoding == GL_SRGB; +} + +angle::Result TextureD3D_Cube::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(size.depth == 1); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + ANGLE_TRY(redefineImage(context, index.cubeMapFaceIndex(), index.getLevelIndex(), + internalFormatInfo.sizedInternalFormat, size, false)); + + return setImageImpl(context, index, type, unpack, unpackBuffer, pixels, 0); +} + +angle::Result TextureD3D_Cube::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(area.depth == 1 && area.z == 0); + return TextureD3D::subImage(context, index, area, format, type, unpack, unpackBuffer, pixels, + 0); +} + +angle::Result TextureD3D_Cube::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(size.depth == 1); + + // compressed formats don't have separate sized internal formats-- we can just use the + // compressed format directly + ANGLE_TRY(redefineImage(context, index.cubeMapFaceIndex(), index.getLevelIndex(), + internalFormat, size, false)); + + return setCompressedImageImpl(context, index, unpack, pixels, 0); +} + +angle::Result TextureD3D_Cube::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(area.depth == 1 && area.z == 0); + + ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0)); + return commitRegion(context, index, area); +} + +angle::Result TextureD3D_Cube::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + GLint faceIndex = index.cubeMapFaceIndex(); + const gl::InternalFormat &internalFormatInfo = + gl::GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE); + + gl::Extents size(sourceArea.width, sourceArea.height, 1); + ANGLE_TRY(redefineImage(context, faceIndex, index.getLevelIndex(), + internalFormatInfo.sizedInternalFormat, size, false)); + + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + + // Does the read area extend beyond the framebuffer? + bool outside = sourceArea.x < 0 || sourceArea.y < 0 || + sourceArea.x + sourceArea.width > fbSize.width || + sourceArea.y + sourceArea.height > fbSize.height; + + // WebGL requires that pixels that would be outside the framebuffer are treated as zero values, + // so clear the mip level to 0 prior to making the copy if any pixel would be sampled outside. + // Same thing for robust resource init. + if (outside && (context->isWebGL() || context->isRobustResourceInitEnabled())) + { + ANGLE_TRY(initializeContents(context, GL_NONE, index)); + } + + gl::Rectangle clippedArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + // Empty source area, nothing to do. + return angle::Result::Continue; + } + + gl::Offset destOffset(clippedArea.x - sourceArea.x, clippedArea.y - sourceArea.y, 0); + + // If the zero max LOD workaround is active, then we can't sample from individual layers of the + // framebuffer in shaders, so we should use the non-rendering copy path. + if (!canCreateRenderTargetForImage(index) || + mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(mImageArray[faceIndex][index.getLevelIndex()]->copyFromFramebuffer( + context, destOffset, clippedArea, source)); + mDirtyImages = true; + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + } + else + { + ANGLE_TRY(ensureRenderTarget(context)); + + ASSERT(size.width == size.height); + + if (size.width > 0 && isValidFaceLevel(faceIndex, index.getLevelIndex())) + { + ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyImageCube(context, source, clippedArea, internalFormat, + destOffset, mTexStorage, index.getTarget(), + index.getLevelIndex())); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + gl::Rectangle clippedArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), &clippedArea)) + { + return angle::Result::Continue; + } + const gl::Offset clippedOffset(destOffset.x + clippedArea.x - sourceArea.x, + destOffset.y + clippedArea.y - sourceArea.y, 0); + + GLint faceIndex = index.cubeMapFaceIndex(); + + // If the zero max LOD workaround is active, then we can't sample from individual layers of the + // framebuffer in shaders, so we should use the non-rendering copy path. + if (!canCreateRenderTargetForImage(index) || + mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(mImageArray[faceIndex][index.getLevelIndex()]->copyFromFramebuffer( + context, clippedOffset, clippedArea, source)); + mDirtyImages = true; + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + } + else + { + ANGLE_TRY(ensureRenderTarget(context)); + if (isValidFaceLevel(faceIndex, index.getLevelIndex())) + { + ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyImageCube( + context, source, clippedArea, gl::GetUnsizedFormat(getBaseLevelInternalFormat()), + clippedOffset, mTexStorage, index.getTarget(), index.getLevelIndex())); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(gl::IsCubeMapFaceTarget(index.getTarget())); + + gl::TextureTarget sourceTarget = NonCubeTextureTypeToTarget(source->getType()); + + GLint faceIndex = index.cubeMapFaceIndex(); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + gl::Extents size(static_cast<int>(source->getWidth(sourceTarget, sourceLevel)), + static_cast<int>(source->getHeight(sourceTarget, sourceLevel)), 1); + ANGLE_TRY(redefineImage(context, faceIndex, index.getLevelIndex(), + internalFormatInfo.sizedInternalFormat, size, false)); + + gl::Box sourceBox(0, 0, 0, size.width, size.height, 1); + gl::Offset destOffset(0, 0, 0); + + if (!isSRGB(index.getLevelIndex(), faceIndex) && canCreateRenderTargetForImage(index)) + { + + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidFaceLevel(faceIndex, index.getLevelIndex())); + ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, index.getLevelIndex())); + + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(sourceLevel); + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, index, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(destOffset, size); + ANGLE_TRY(commitRegion(context, index, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(gl::IsCubeMapFaceTarget(index.getTarget())); + + GLint faceIndex = index.cubeMapFaceIndex(); + + if (!isSRGB(index.getLevelIndex(), faceIndex) && canCreateRenderTargetForImage(index)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidFaceLevel(faceIndex, index.getLevelIndex())); + ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, index.getLevelIndex())); + + const gl::InternalFormat &internalFormatInfo = + gl::GetSizedInternalFormatInfo(getInternalFormat(index.getLevelIndex(), faceIndex)); + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(sourceLevel); + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, index, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(destOffset.x, destOffset.y, 0, sourceBox.width, sourceBox.height, 1); + ANGLE_TRY(commitRegion(context, index, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) +{ + ASSERT(size.width == size.height); + ASSERT(size.depth == 1); + + for (size_t level = 0; level < levels; level++) + { + GLsizei mipSize = std::max(1, size.width >> level); + for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++) + { + mImageArray[faceIndex][level]->redefine(gl::TextureType::CubeMap, internalFormat, + gl::Extents(mipSize, mipSize, 1), true); + } + } + + for (size_t level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++) + { + mImageArray[faceIndex][level]->redefine(gl::TextureType::CubeMap, GL_NONE, + gl::Extents(0, 0, 0), true); + } + } + + // TODO(geofflang): Verify storage creation had no errors + BindFlags bindFlags; + bindFlags.renderTarget = IsRenderTargetUsage(mState.getUsage()); + + TexStoragePointer storage = { + mRenderer->createTextureStorageCube(internalFormat, bindFlags, size.width, + static_cast<int>(levels), false, mState.getLabel()), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ANGLE_TRY(updateStorage(context)); + + mImmutable = true; + + return angle::Result::Continue; +} + +// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. +bool TextureD3D_Cube::isCubeComplete() const +{ + int baseWidth = getBaseLevelWidth(); + int baseHeight = getBaseLevelHeight(); + GLenum baseFormat = getBaseLevelInternalFormat(); + + if (baseWidth <= 0 || baseWidth != baseHeight) + { + return false; + } + + for (size_t faceIndex = 1; faceIndex < gl::kCubeFaceCount; faceIndex++) + { + const ImageD3D &faceBaseImage = *mImageArray[faceIndex][getBaseLevel()]; + + if (faceBaseImage.getWidth() != baseWidth || faceBaseImage.getHeight() != baseHeight || + faceBaseImage.getInternalFormat() != baseFormat) + { + return false; + } + } + + return true; +} + +angle::Result TextureD3D_Cube::bindTexImage(const gl::Context *context, egl::Surface *surface) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::releaseTexImage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::initMipmapImages(const gl::Context *context) +{ + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + // Purge array levels baseLevel + 1 through q and reset them to represent the generated mipmap + // levels. + for (int faceIndex = 0; faceIndex < static_cast<int>(gl::kCubeFaceCount); faceIndex++) + { + for (GLuint level = baseLevel + 1; level <= maxLevel; level++) + { + int faceLevelSize = + (std::max(mImageArray[faceIndex][baseLevel]->getWidth() >> (level - baseLevel), 1)); + ANGLE_TRY(redefineImage(context, faceIndex, level, + mImageArray[faceIndex][baseLevel]->getInternalFormat(), + gl::Extents(faceLevelSize, faceLevelSize, 1), false)); + } + } + + // We should be mip-complete now so generate the storage. + ANGLE_TRY(initializeStorage(context, BindFlags::RenderTarget())); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(gl::IsCubeMapFaceTarget(index.getTarget())); + + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + ANGLE_TRY(updateStorageFaceLevel(context, index.cubeMapFaceIndex(), index.getLevelIndex())); + + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +angle::Result TextureD3D_Cube::initializeStorage(const gl::Context *context, BindFlags bindFlags) +{ + // Only initialize the first time this texture is used as a render target or shader resource + if (mTexStorage) + { + return angle::Result::Continue; + } + + // do not attempt to create storage for nonexistant data + if (!isFaceLevelComplete(0, getBaseLevel())) + { + return angle::Result::Continue; + } + + bindFlags.renderTarget |= IsRenderTargetUsage(mState.getUsage()); + + TexStoragePointer storage; + ANGLE_TRY(createCompleteStorage(context, bindFlags, &storage)); + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ASSERT(mTexStorage); + + // flush image data to the storage + ANGLE_TRY(updateStorage(context)); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + GLsizei size = getLevelZeroWidth(); + + ASSERT(size > 0); + + // use existing storage level count, when previously specified by TexStorage*D + GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(size, size, 1)); + + bool hintLevelZeroOnly = false; + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // If any of the CPU images (levels >= 1) are dirty, then the textureStorageEXT should use + // the mipped texture to begin with. Otherwise, it should use the level-zero-only texture. + hintLevelZeroOnly = true; + for (int faceIndex = 0; + faceIndex < static_cast<int>(gl::kCubeFaceCount) && hintLevelZeroOnly; faceIndex++) + { + for (int level = 1; level < levels && hintLevelZeroOnly; level++) + { + hintLevelZeroOnly = !(mImageArray[faceIndex][level]->isDirty() && + isFaceLevelComplete(faceIndex, level)); + } + } + } + + // TODO (geofflang): detect if storage creation succeeded + *outStorage = { + mRenderer->createTextureStorageCube(getBaseLevelInternalFormat(), bindFlags, size, levels, + hintLevelZeroOnly, mState.getLabel()), + context}; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + if (newCompleteTexStorage && newCompleteTexStorage->isManaged()) + { + for (int faceIndex = 0; faceIndex < static_cast<int>(gl::kCubeFaceCount); faceIndex++) + { + for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++) + { + ANGLE_TRY(mImageArray[faceIndex][level]->setManagedSurfaceCube( + context, newCompleteTexStorage, faceIndex, level)); + } + } + } + + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + + mDirtyImages = true; + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::updateStorage(const gl::Context *context) +{ + if (!mDirtyImages) + { + return angle::Result::Continue; + } + + ASSERT(mTexStorage != nullptr); + GLint storageLevels = mTexStorage->getLevelCount(); + for (int face = 0; face < static_cast<int>(gl::kCubeFaceCount); face++) + { + for (int level = 0; level < storageLevels; level++) + { + if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level)) + { + ANGLE_TRY(updateStorageFaceLevel(context, face, level)); + } + } + } + + mDirtyImages = false; + return angle::Result::Continue; +} + +bool TextureD3D_Cube::isValidFaceLevel(int faceIndex, int level) const +{ + return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); +} + +bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const +{ + if (getBaseLevel() >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + return false; + } + ASSERT(level >= 0 && static_cast<size_t>(faceIndex) < gl::kCubeFaceCount && + level < static_cast<int>(mImageArray[faceIndex].size()) && + mImageArray[faceIndex][level] != nullptr); + + if (isImmutable()) + { + return true; + } + + int levelZeroSize = getLevelZeroWidth(); + + if (levelZeroSize <= 0) + { + return false; + } + + // Check that non-zero levels are consistent with the base level. + const ImageD3D *faceLevelImage = mImageArray[faceIndex][level].get(); + + if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat()) + { + return false; + } + + if (faceLevelImage->getWidth() != std::max(1, levelZeroSize >> level)) + { + return false; + } + + return true; +} + +bool TextureD3D_Cube::isImageComplete(const gl::ImageIndex &index) const +{ + return isFaceLevelComplete(index.cubeMapFaceIndex(), index.getLevelIndex()); +} + +angle::Result TextureD3D_Cube::updateStorageFaceLevel(const gl::Context *context, + int faceIndex, + int level) +{ + ASSERT(level >= 0 && static_cast<size_t>(faceIndex) < gl::kCubeFaceCount && + level < static_cast<int>(mImageArray[faceIndex].size()) && + mImageArray[faceIndex][level] != nullptr); + ImageD3D *image = mImageArray[faceIndex][level].get(); + + if (image->isDirty()) + { + gl::TextureTarget faceTarget = gl::CubeFaceIndexToTextureTarget(faceIndex); + gl::ImageIndex index = gl::ImageIndex::MakeCubeMapFace(faceTarget, level); + gl::Box region(0, 0, 0, image->getWidth(), image->getHeight(), 1); + ANGLE_TRY(commitRegion(context, index, region)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Cube::redefineImage(const gl::Context *context, + int faceIndex, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + // If there currently is a corresponding storage texture image, it has these parameters + const int storageWidth = std::max(1, getLevelZeroWidth() >> level); + const int storageHeight = std::max(1, getLevelZeroHeight() >> level); + const GLenum storageFormat = getBaseLevelInternalFormat(); + + if (mTexStorage) + { + const int storageLevels = mTexStorage->getLevelCount(); + + if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth || + size.height != storageHeight || + internalformat != storageFormat) // Discard mismatched storage + { + markAllImagesDirty(); + + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + copyImageMask.set(level, false); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + } + } + + mImageArray[faceIndex][level]->redefine(gl::TextureType::CubeMap, internalformat, size, + forceRelease); + mDirtyImages = mDirtyImages || mImageArray[faceIndex][level]->isDirty(); + + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_Cube::imageIterator() const +{ + return gl::ImageIndexIterator::MakeCube(0, mTexStorage->getLevelCount()); +} + +gl::ImageIndex TextureD3D_Cube::getImageIndex(GLint mip, GLint layer) const +{ + // The "layer" of the image index corresponds to the cube face + return gl::ImageIndex::MakeCubeMapFace(gl::CubeFaceIndexToTextureTarget(layer), mip); +} + +bool TextureD3D_Cube::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::CubeMap && + gl::IsCubeMapFaceTarget(index.getTarget()) && index.getLevelIndex() >= 0 && + index.getLevelIndex() < mTexStorage->getLevelCount()); +} + +void TextureD3D_Cube::markAllImagesDirty() +{ + for (int dirtyLevel = 0; dirtyLevel < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; dirtyLevel++) + { + for (size_t dirtyFace = 0; dirtyFace < gl::kCubeFaceCount; dirtyFace++) + { + mImageArray[dirtyFace][dirtyLevel]->markDirty(); + } + } + mDirtyImages = true; +} + +TextureD3D_3D::TextureD3D_3D(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3D(state, renderer) +{ + for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i) + { + mImageArray[i].reset(renderer->createImage()); + } +} + +void TextureD3D_3D::onDestroy(const gl::Context *context) +{ + // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage + // for some of their data. If TextureStorage is deleted before the Images, then their data will + // be wastefully copied back from the GPU before we delete the Images. + for (auto &image : mImageArray) + { + image.reset(); + } + return TextureD3D::onDestroy(context); +} + +TextureD3D_3D::~TextureD3D_3D() {} + +ImageD3D *TextureD3D_3D::getImage(int level, int layer) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(layer == 0); + return mImageArray[level].get(); +} + +ImageD3D *TextureD3D_3D::getImage(const gl::ImageIndex &index) const +{ + ASSERT(index.getLevelIndex() < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(!index.hasLayer()); + ASSERT(index.getType() == gl::TextureType::_3D); + return mImageArray[index.getLevelIndex()].get(); +} + +GLsizei TextureD3D_3D::getLayerCount(int level) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + return 1; +} + +GLsizei TextureD3D_3D::getWidth(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getWidth(); + else + return 0; +} + +GLsizei TextureD3D_3D::getHeight(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getHeight(); + else + return 0; +} + +GLsizei TextureD3D_3D::getDepth(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getDepth(); + else + return 0; +} + +GLenum TextureD3D_3D::getInternalFormat(GLint level) const +{ + if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + return mImageArray[level]->getInternalFormat(); + else + return GL_NONE; +} + +bool TextureD3D_3D::isDepth(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0; +} + +bool TextureD3D_3D::isSRGB(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).colorEncoding == GL_SRGB; +} + +angle::Result TextureD3D_3D::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + size, false)); + + bool fastUnpacked = false; + + // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer + if (isFastUnpackable(unpackBuffer, unpack, internalFormatInfo.sizedInternalFormat) && + !size.empty() && isLevelComplete(index.getLevelIndex())) + { + // Will try to create RT storage if it does not exist + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, index, getRenderToTextureSamples(), &destRenderTarget)); + + gl::Box destArea(0, 0, 0, getWidth(index.getLevelIndex()), getHeight(index.getLevelIndex()), + getDepth(index.getLevelIndex())); + + ANGLE_TRY(fastUnpackPixels(context, unpack, unpackBuffer, pixels, destArea, + internalFormatInfo.sizedInternalFormat, type, destRenderTarget)); + + // Ensure we don't overwrite our newly initialized data + mImageArray[index.getLevelIndex()]->markClean(); + + fastUnpacked = true; + } + + if (!fastUnpacked) + { + ANGLE_TRY(setImageImpl(context, index, type, unpack, unpackBuffer, pixels, 0)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer + GLenum mipFormat = getInternalFormat(index.getLevelIndex()); + if (isFastUnpackable(unpackBuffer, unpack, mipFormat) && isLevelComplete(index.getLevelIndex())) + { + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(getRenderTarget(context, index, getRenderToTextureSamples(), &destRenderTarget)); + ASSERT(!mImageArray[index.getLevelIndex()]->isDirty()); + + return fastUnpackPixels(context, unpack, unpackBuffer, pixels, area, mipFormat, type, + destRenderTarget); + } + else + { + return TextureD3D::subImage(context, index, area, format, type, unpack, unpackBuffer, + pixels, 0); + } +} + +angle::Result TextureD3D_3D::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + // compressed formats don't have separate sized internal formats-- we can just use the + // compressed format directly + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormat, size, false)); + + return setCompressedImageImpl(context, index, unpack, pixels, 0); +} + +angle::Result TextureD3D_3D::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0)); + return commitRegion(context, index, area); +} + +angle::Result TextureD3D_3D::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + gl::Rectangle clippedSourceArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), + &clippedSourceArea)) + { + return angle::Result::Continue; + } + const gl::Offset clippedDestOffset(destOffset.x + clippedSourceArea.x - sourceArea.x, + destOffset.y + clippedSourceArea.y - sourceArea.y, + destOffset.z); + + // Currently, copying directly to the storage is not possible because it's not possible to + // create an SRV from a single layer of a 3D texture. Instead, make sure the image is up to + // date before the copy and then copy back to the storage afterwards if needed. + // TODO: Investigate 3D blits in D3D11. + + bool syncTexStorage = mTexStorage && isLevelComplete(index.getLevelIndex()); + if (syncTexStorage) + { + ANGLE_TRY( + mImageArray[index.getLevelIndex()]->copyFromTexStorage(context, index, mTexStorage)); + } + ANGLE_TRY(mImageArray[index.getLevelIndex()]->copyFromFramebuffer(context, clippedDestOffset, + clippedSourceArea, source)); + mDirtyImages = true; + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + + if (syncTexStorage) + { + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + gl::TextureType sourceType = source->getType(); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + gl::Extents size( + static_cast<int>(source->getWidth(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + static_cast<int>(source->getHeight(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + static_cast<int>(source->getDepth(NonCubeTextureTypeToTarget(sourceType), sourceLevel))); + + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + size, false)); + + gl::Box sourceBox(0, 0, 0, size.width, size.height, size.depth); + gl::Offset destOffset(0, 0, 0); + gl::ImageIndex destIndex = gl::ImageIndex::Make3D(static_cast<GLint>(index.getLevelIndex())); + + if (!isSRGB(index.getLevelIndex()) && canCreateRenderTargetForImage(destIndex)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(index.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_3D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceIndex = gl::ImageIndex::Make3D(sourceLevel); + ImageD3D *sourceImage = nullptr; + ImageD3D *destImage = nullptr; + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + + ANGLE_TRY(getImageAndSyncFromStorage(context, destIndex, &destImage)); + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceIndex, &sourceImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(0, 0, 0, sourceBox.width, sourceBox.height, sourceBox.depth); + ANGLE_TRY(commitRegion(context, destIndex, destRegion)); + } + + return angle::Result::Continue; +} +angle::Result TextureD3D_3D::copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_3D); + + gl::ImageIndex destIndex = gl::ImageIndex::Make3D(static_cast<GLint>(index.getLevelIndex())); + + if (!isSRGB(index.getLevelIndex()) && canCreateRenderTargetForImage(destIndex)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(index.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + + const gl::InternalFormat &internalFormatInfo = + gl::GetSizedInternalFormatInfo(getInternalFormat(index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_3D, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make3D(sourceLevel); + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, destIndex, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + + mDirtyImages = true; + + gl::Box destRegion(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, + sourceBox.height, sourceBox.depth); + ANGLE_TRY(commitRegion(context, destIndex, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) +{ + ASSERT(type == gl::TextureType::_3D); + + for (size_t level = 0; level < levels; level++) + { + gl::Extents levelSize(std::max(1, size.width >> level), std::max(1, size.height >> level), + std::max(1, size.depth >> level)); + mImageArray[level]->redefine(gl::TextureType::_3D, internalFormat, levelSize, true); + } + + for (size_t level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + mImageArray[level]->redefine(gl::TextureType::_3D, GL_NONE, gl::Extents(0, 0, 0), true); + } + + // TODO(geofflang): Verify storage creation had no errors + BindFlags bindFlags; + bindFlags.renderTarget = IsRenderTargetUsage(mState.getUsage()); + TexStoragePointer storage = { + mRenderer->createTextureStorage3D(internalFormat, bindFlags, size.width, size.height, + size.depth, static_cast<int>(levels), mState.getLabel()), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ANGLE_TRY(updateStorage(context)); + + mImmutable = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::bindTexImage(const gl::Context *context, egl::Surface *surface) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::releaseTexImage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::initMipmapImages(const gl::Context *context) +{ + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + // Purge array levels baseLevel + 1 through q and reset them to represent the generated mipmap + // levels. + for (GLuint level = baseLevel + 1; level <= maxLevel; level++) + { + gl::Extents levelSize(std::max(getLevelZeroWidth() >> level, 1), + std::max(getLevelZeroHeight() >> level, 1), + std::max(getLevelZeroDepth() >> level, 1)); + ANGLE_TRY(redefineImage(context, level, getBaseLevelInternalFormat(), levelSize, false)); + } + + // We should be mip-complete now so generate the storage. + ANGLE_TRY(initializeStorage(context, BindFlags::RenderTarget())); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + + if (index.hasLayer()) + { + ANGLE_TRY(updateStorage(context)); + } + else + { + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + } + + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +angle::Result TextureD3D_3D::initializeStorage(const gl::Context *context, BindFlags bindFlags) +{ + // Only initialize the first time this texture is used as a render target or shader resource + if (mTexStorage) + { + return angle::Result::Continue; + } + + // do not attempt to create storage for nonexistant data + if (!isLevelComplete(getBaseLevel())) + { + return angle::Result::Continue; + } + + TexStoragePointer storage; + ANGLE_TRY(createCompleteStorage(context, bindFlags, &storage)); + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ASSERT(mTexStorage); + + // flush image data to the storage + ANGLE_TRY(updateStorage(context)); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + GLsizei depth = getLevelZeroDepth(); + GLenum internalFormat = getBaseLevelInternalFormat(); + + ASSERT(width > 0 && height > 0 && depth > 0); + + // use existing storage level count, when previously specified by TexStorage*D + GLint levels = + (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, depth)); + + // TODO: Verify creation of the storage succeeded + *outStorage = {mRenderer->createTextureStorage3D(internalFormat, bindFlags, width, height, + depth, levels, mState.getLabel()), + context}; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + mDirtyImages = true; + + // We do not support managed 3D storage, as that is D3D9/ES2-only + ASSERT(!mTexStorage->isManaged()); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::updateStorage(const gl::Context *context) +{ + if (!mDirtyImages) + { + return angle::Result::Continue; + } + + ASSERT(mTexStorage != nullptr); + GLint storageLevels = mTexStorage->getLevelCount(); + for (int level = 0; level < storageLevels; level++) + { + if (mImageArray[level]->isDirty() && isLevelComplete(level)) + { + ANGLE_TRY(updateStorageLevel(context, level)); + } + } + + mDirtyImages = false; + return angle::Result::Continue; +} + +bool TextureD3D_3D::isValidLevel(int level) const +{ + return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); +} + +bool TextureD3D_3D::isLevelComplete(int level) const +{ + ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) && + mImageArray[level] != nullptr); + + if (isImmutable()) + { + return true; + } + + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + GLsizei depth = getLevelZeroDepth(); + + if (width <= 0 || height <= 0 || depth <= 0) + { + return false; + } + + if (level == static_cast<int>(getBaseLevel())) + { + return true; + } + + ImageD3D *levelImage = mImageArray[level].get(); + + if (levelImage->getInternalFormat() != getBaseLevelInternalFormat()) + { + return false; + } + + if (levelImage->getWidth() != std::max(1, width >> level)) + { + return false; + } + + if (levelImage->getHeight() != std::max(1, height >> level)) + { + return false; + } + + if (levelImage->getDepth() != std::max(1, depth >> level)) + { + return false; + } + + return true; +} + +bool TextureD3D_3D::isImageComplete(const gl::ImageIndex &index) const +{ + return isLevelComplete(index.getLevelIndex()); +} + +angle::Result TextureD3D_3D::updateStorageLevel(const gl::Context *context, int level) +{ + ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) && + mImageArray[level] != nullptr); + ASSERT(isLevelComplete(level)); + + if (mImageArray[level]->isDirty()) + { + gl::ImageIndex index = gl::ImageIndex::Make3D(level); + gl::Box region(0, 0, 0, getWidth(level), getHeight(level), getDepth(level)); + ANGLE_TRY(commitRegion(context, index, region)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_3D::redefineImage(const gl::Context *context, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + // If there currently is a corresponding storage texture image, it has these parameters + const int storageWidth = std::max(1, getLevelZeroWidth() >> level); + const int storageHeight = std::max(1, getLevelZeroHeight() >> level); + const int storageDepth = std::max(1, getLevelZeroDepth() >> level); + const GLenum storageFormat = getBaseLevelInternalFormat(); + + if (mTexStorage) + { + const int storageLevels = mTexStorage->getLevelCount(); + + if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth || + size.height != storageHeight || size.depth != storageDepth || + internalformat != storageFormat) // Discard mismatched storage + { + markAllImagesDirty(); + + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + copyImageMask.set(level, false); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + } + } + + mImageArray[level]->redefine(gl::TextureType::_3D, internalformat, size, forceRelease); + mDirtyImages = mDirtyImages || mImageArray[level]->isDirty(); + + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_3D::imageIterator() const +{ + return gl::ImageIndexIterator::Make3D(0, mTexStorage->getLevelCount(), + gl::ImageIndex::kEntireLevel, + gl::ImageIndex::kEntireLevel); +} + +gl::ImageIndex TextureD3D_3D::getImageIndex(GLint mip, GLint /*layer*/) const +{ + // The "layer" here does not apply to 3D images. We use one Image per mip. + return gl::ImageIndex::Make3D(mip); +} + +bool TextureD3D_3D::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::_3D && index.getLevelIndex() >= 0 && + index.getLevelIndex() < mTexStorage->getLevelCount()); +} + +void TextureD3D_3D::markAllImagesDirty() +{ + for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + mImageArray[i]->markDirty(); + } + mDirtyImages = true; +} + +GLint TextureD3D_3D::getLevelZeroDepth() const +{ + ASSERT(gl::CountLeadingZeros(static_cast<uint32_t>(getBaseLevelDepth())) > getBaseLevel()); + return getBaseLevelDepth() << getBaseLevel(); +} + +TextureD3D_2DArray::TextureD3D_2DArray(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3D(state, renderer) +{ + for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level) + { + mLayerCounts[level] = 0; + mImageArray[level] = nullptr; + } +} + +void TextureD3D_2DArray::onDestroy(const gl::Context *context) +{ + // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage + // for some of their data. If TextureStorage is deleted before the Images, then their data will + // be wastefully copied back from the GPU before we delete the Images. + deleteImages(); + return TextureD3D::onDestroy(context); +} + +TextureD3D_2DArray::~TextureD3D_2DArray() {} + +ImageD3D *TextureD3D_2DArray::getImage(int level, int layer) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT((layer == 0 && mLayerCounts[level] == 0) || layer < mLayerCounts[level]); + return (mImageArray[level] ? mImageArray[level][layer] : nullptr); +} + +ImageD3D *TextureD3D_2DArray::getImage(const gl::ImageIndex &index) const +{ + ASSERT(index.getLevelIndex() < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(index.hasLayer()); + ASSERT((index.getLayerIndex() == 0 && mLayerCounts[index.getLevelIndex()] == 0) || + index.getLayerIndex() < mLayerCounts[index.getLevelIndex()]); + ASSERT(index.getType() == gl::TextureType::_2DArray); + return (mImageArray[index.getLevelIndex()] + ? mImageArray[index.getLevelIndex()][index.getLayerIndex()] + : nullptr); +} + +GLsizei TextureD3D_2DArray::getLayerCount(int level) const +{ + ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + return mLayerCounts[level]; +} + +GLsizei TextureD3D_2DArray::getWidth(GLint level) const +{ + return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) + ? mImageArray[level][0]->getWidth() + : 0; +} + +GLsizei TextureD3D_2DArray::getHeight(GLint level) const +{ + return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) + ? mImageArray[level][0]->getHeight() + : 0; +} + +GLenum TextureD3D_2DArray::getInternalFormat(GLint level) const +{ + return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) + ? mImageArray[level][0]->getInternalFormat() + : GL_NONE; +} + +bool TextureD3D_2DArray::isDepth(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0; +} + +bool TextureD3D_2DArray::isSRGB(GLint level) const +{ + return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).colorEncoding == GL_SRGB; +} + +angle::Result TextureD3D_2DArray::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat, type); + + ANGLE_TRY( + redefineImage(context, index.getLevelIndex(), formatInfo.sizedInternalFormat, size, false)); + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH(contextD3D, formatInfo.computeDepthPitch( + type, size.width, size.height, unpack.alignment, + unpack.rowLength, unpack.imageHeight, &inputDepthPitch)); + + for (int i = 0; i < size.depth; i++) + { + const ptrdiff_t layerOffset = (inputDepthPitch * i); + gl::ImageIndex layerIndex = gl::ImageIndex::Make2DArray(index.getLevelIndex(), i); + ANGLE_TRY( + setImageImpl(context, layerIndex, type, unpack, unpackBuffer, pixels, layerOffset)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + const gl::InternalFormat &formatInfo = + gl::GetInternalFormatInfo(getInternalFormat(index.getLevelIndex()), type); + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH(contextD3D, formatInfo.computeDepthPitch( + type, area.width, area.height, unpack.alignment, + unpack.rowLength, unpack.imageHeight, &inputDepthPitch)); + + for (int i = 0; i < area.depth; i++) + { + int layer = area.z + i; + const ptrdiff_t layerOffset = (inputDepthPitch * i); + + gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1); + + gl::ImageIndex layerIndex = gl::ImageIndex::Make2DArray(index.getLevelIndex(), layer); + ANGLE_TRY(TextureD3D::subImage(context, layerIndex, layerArea, format, type, unpack, + unpackBuffer, pixels, layerOffset)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + + // compressed formats don't have separate sized internal formats-- we can just use the + // compressed format directly + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormat, size, false)); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalFormat); + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH( + contextD3D, formatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, size.width, size.height, 1, 0, 0, + &inputDepthPitch)); + + for (int i = 0; i < size.depth; i++) + { + const ptrdiff_t layerOffset = (inputDepthPitch * i); + + gl::ImageIndex layerIndex = gl::ImageIndex::Make2DArray(index.getLevelIndex(), i); + ANGLE_TRY(setCompressedImageImpl(context, layerIndex, unpack, pixels, layerOffset)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + ContextD3D *contextD3D = GetImplAs<ContextD3D>(context); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(format); + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH( + contextD3D, formatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, area.width, area.height, 1, 0, 0, + &inputDepthPitch)); + + for (int i = 0; i < area.depth; i++) + { + int layer = area.z + i; + const ptrdiff_t layerOffset = (inputDepthPitch * i); + + gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1); + + gl::ImageIndex layerIndex = gl::ImageIndex::Make2DArray(index.getLevelIndex(), layer); + ANGLE_TRY(TextureD3D::subImageCompressed(context, layerIndex, layerArea, format, unpack, + pixels, layerOffset)); + ANGLE_TRY(commitRegion(context, layerIndex, layerArea)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + gl::Extents fbSize = source->getReadColorAttachment()->getSize(); + gl::Rectangle clippedSourceArea; + if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height), + &clippedSourceArea)) + { + return angle::Result::Continue; + } + const gl::Offset clippedDestOffset(destOffset.x + clippedSourceArea.x - sourceArea.x, + destOffset.y + clippedSourceArea.y - sourceArea.y, + destOffset.z); + + if (!canCreateRenderTargetForImage(index)) + { + gl::Offset destLayerOffset(clippedDestOffset.x, clippedDestOffset.y, 0); + ANGLE_TRY(mImageArray[index.getLevelIndex()][clippedDestOffset.z]->copyFromFramebuffer( + context, destLayerOffset, clippedSourceArea, source)); + mDirtyImages = true; + onStateChange(angle::SubjectMessage::DirtyBitsFlagged); + } + else + { + ANGLE_TRY(ensureRenderTarget(context)); + + if (isValidLevel(index.getLevelIndex())) + { + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + ANGLE_TRY( + mRenderer->copyImage2DArray(context, source, clippedSourceArea, + gl::GetUnsizedFormat(getInternalFormat(getBaseLevel())), + clippedDestOffset, mTexStorage, index.getLevelIndex())); + } + } + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + gl::TextureType sourceType = source->getType(); + + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type); + gl::Extents size( + static_cast<int>(source->getWidth(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + static_cast<int>(source->getHeight(NonCubeTextureTypeToTarget(sourceType), sourceLevel)), + static_cast<int>(source->getDepth(NonCubeTextureTypeToTarget(sourceType), sourceLevel))); + + ANGLE_TRY(redefineImage(context, index.getLevelIndex(), internalFormatInfo.sizedInternalFormat, + size, false)); + + gl::Box sourceBox(0, 0, 0, size.width, size.height, size.depth); + gl::Offset destOffset(0, 0, 0); + + gl::ImageIndex destIndex = + gl::ImageIndex::Make2DArrayRange(index.getLevelIndex(), 0, size.depth); + + if (!isSRGB(index.getLevelIndex()) && + canCreateRenderTargetForImage( + gl::ImageIndex::Make2DArrayRange(index.getLevelIndex(), 0, size.depth))) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(index.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2DArray, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + for (int i = 0; i < size.depth; i++) + { + gl::ImageIndex currentSourceDepthIndex = gl::ImageIndex::Make2DArray(sourceLevel, i); + gl::ImageIndex currentDestDepthIndex = + gl::ImageIndex::Make2DArray(index.getLevelIndex(), i); + ImageD3D *sourceImage = nullptr; + ImageD3D *destImage = nullptr; + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + + ANGLE_TRY(getImageAndSyncFromStorage(context, currentDestDepthIndex, &destImage)); + ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, currentSourceDepthIndex, + &sourceImage)); + gl::Box imageBox(sourceBox.x, sourceBox.y, 0, sourceBox.width, sourceBox.height, 1); + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, imageBox, destOffset, + unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha)); + } + + mDirtyImages = true; + + gl::Box destRegion(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, + sourceBox.height, sourceBox.depth); + ANGLE_TRY(commitRegion(context, destIndex, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) +{ + ASSERT(index.getTarget() == gl::TextureTarget::_2DArray); + + gl::ImageIndex destIndex = gl::ImageIndex::Make2DArrayRange( + static_cast<GLint>(index.getLevelIndex()), destOffset.z, sourceBox.depth - destOffset.z); + + if (!isSRGB(destIndex.getLevelIndex()) && canCreateRenderTargetForImage(destIndex)) + { + ANGLE_TRY(ensureRenderTarget(context)); + ASSERT(isValidLevel(destIndex.getLevelIndex())); + ANGLE_TRY(updateStorageLevel(context, destIndex.getLevelIndex())); + + const gl::InternalFormat &internalFormatInfo = + gl::GetSizedInternalFormatInfo(getInternalFormat(destIndex.getLevelIndex())); + ANGLE_TRY(mRenderer->copyTexture(context, source, sourceLevel, gl::TextureTarget::_2DArray, + sourceBox, internalFormatInfo.format, + internalFormatInfo.type, destOffset, mTexStorage, + index.getTarget(), index.getLevelIndex(), unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + } + else + { + for (int i = 0; i < sourceBox.depth; i++) + { + gl::ImageIndex currentSourceIndex = + gl::ImageIndex::Make2DArray(sourceLevel, i + sourceBox.z); + gl::ImageIndex currentDestIndex = + gl::ImageIndex::Make2DArray(index.getLevelIndex(), i + destOffset.z); + + gl::Box currentLayerBox(sourceBox.x, sourceBox.y, 0, sourceBox.width, sourceBox.height, + 1); + + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ImageD3D *sourceImage = nullptr; + ANGLE_TRY( + sourceD3D->getImageAndSyncFromStorage(context, currentSourceIndex, &sourceImage)); + + ImageD3D *destImage = nullptr; + ANGLE_TRY(getImageAndSyncFromStorage(context, currentDestIndex, &destImage)); + + ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, currentLayerBox, + destOffset, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha)); + } + + mDirtyImages = true; + + gl::Box destRegion(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, + sourceBox.height, sourceBox.depth); + ANGLE_TRY(commitRegion(context, destIndex, destRegion)); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) +{ + ASSERT(type == gl::TextureType::_2DArray); + + deleteImages(); + + for (size_t level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + gl::Extents levelLayerSize(std::max(1, size.width >> level), + std::max(1, size.height >> level), 1); + + mLayerCounts[level] = (level < levels ? size.depth : 0); + + if (mLayerCounts[level] > 0) + { + // Create new images for this level + mImageArray[level] = new ImageD3D *[mLayerCounts[level]]; + + for (int layer = 0; layer < mLayerCounts[level]; layer++) + { + mImageArray[level][layer] = mRenderer->createImage(); + mImageArray[level][layer]->redefine(gl::TextureType::_2DArray, internalFormat, + levelLayerSize, true); + } + } + } + + // TODO(geofflang): Verify storage creation had no errors + BindFlags bindFlags; + bindFlags.renderTarget = IsRenderTargetUsage(mState.getUsage()); + TexStoragePointer storage = {mRenderer->createTextureStorage2DArray( + internalFormat, bindFlags, size.width, size.height, size.depth, + static_cast<int>(levels), mState.getLabel()), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ANGLE_TRY(updateStorage(context)); + + mImmutable = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::bindTexImage(const gl::Context *context, egl::Surface *surface) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::releaseTexImage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::initMipmapImages(const gl::Context *context) +{ + const GLuint baseLevel = mState.getEffectiveBaseLevel(); + const GLuint maxLevel = mState.getMipmapMaxLevel(); + int baseWidth = getLevelZeroWidth(); + int baseHeight = getLevelZeroHeight(); + int baseDepth = getLayerCount(getBaseLevel()); + GLenum baseFormat = getBaseLevelInternalFormat(); + + // Purge array levels baseLevel + 1 through q and reset them to represent the generated mipmap + // levels. + for (GLuint level = baseLevel + 1u; level <= maxLevel; level++) + { + ASSERT((baseWidth >> level) > 0 || (baseHeight >> level) > 0); + gl::Extents levelLayerSize(std::max(baseWidth >> level, 1), + std::max(baseHeight >> level, 1), baseDepth); + ANGLE_TRY(redefineImage(context, level, baseFormat, levelLayerSize, false)); + } + + // We should be mip-complete now so generate the storage. + ANGLE_TRY(initializeStorage(context, BindFlags::RenderTarget())); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + ANGLE_TRY(updateStorageLevel(context, index.getLevelIndex())); + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +angle::Result TextureD3D_2DArray::initializeStorage(const gl::Context *context, BindFlags bindFlags) +{ + // Only initialize the first time this texture is used as a render target or shader resource + if (mTexStorage) + { + return angle::Result::Continue; + } + + // do not attempt to create storage for nonexistant data + if (!isLevelComplete(getBaseLevel())) + { + return angle::Result::Continue; + } + + bindFlags.renderTarget |= IsRenderTargetUsage(mState.getUsage()); + + TexStoragePointer storage; + ANGLE_TRY(createCompleteStorage(context, bindFlags, &storage)); + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + ASSERT(mTexStorage); + + // flush image data to the storage + ANGLE_TRY(updateStorage(context)); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + GLsizei depth = getLayerCount(getBaseLevel()); + GLenum internalFormat = getBaseLevelInternalFormat(); + + ASSERT(width > 0 && height > 0 && depth > 0); + + // use existing storage level count, when previously specified by TexStorage*D + GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1)); + + // TODO(geofflang): Verify storage creation succeeds + *outStorage = {mRenderer->createTextureStorage2DArray(internalFormat, bindFlags, width, height, + depth, levels, mState.getLabel()), + context}; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + mDirtyImages = true; + + // We do not support managed 2D array storage, as managed storage is ES2/D3D9 only + ASSERT(!mTexStorage->isManaged()); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DArray::updateStorage(const gl::Context *context) +{ + if (!mDirtyImages) + { + return angle::Result::Continue; + } + + ASSERT(mTexStorage != nullptr); + GLint storageLevels = mTexStorage->getLevelCount(); + for (int level = 0; level < storageLevels; level++) + { + if (isLevelComplete(level)) + { + ANGLE_TRY(updateStorageLevel(context, level)); + } + } + + mDirtyImages = false; + return angle::Result::Continue; +} + +bool TextureD3D_2DArray::isValidLevel(int level) const +{ + return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); +} + +bool TextureD3D_2DArray::isLevelComplete(int level) const +{ + ASSERT(level >= 0 && level < (int)ArraySize(mImageArray)); + + if (isImmutable()) + { + return true; + } + + GLsizei width = getLevelZeroWidth(); + GLsizei height = getLevelZeroHeight(); + + if (width <= 0 || height <= 0) + { + return false; + } + + // Layers check needs to happen after the above checks, otherwise out-of-range base level may be + // queried. + GLsizei layers = getLayerCount(getBaseLevel()); + + if (layers <= 0) + { + return false; + } + + if (level == static_cast<int>(getBaseLevel())) + { + return true; + } + + if (getInternalFormat(level) != getInternalFormat(getBaseLevel())) + { + return false; + } + + if (getWidth(level) != std::max(1, width >> level)) + { + return false; + } + + if (getHeight(level) != std::max(1, height >> level)) + { + return false; + } + + if (getLayerCount(level) != layers) + { + return false; + } + + return true; +} + +bool TextureD3D_2DArray::isImageComplete(const gl::ImageIndex &index) const +{ + return isLevelComplete(index.getLevelIndex()); +} + +angle::Result TextureD3D_2DArray::updateStorageLevel(const gl::Context *context, int level) +{ + ASSERT(level >= 0 && level < static_cast<int>(ArraySize(mLayerCounts))); + ASSERT(isLevelComplete(level)); + + for (int layer = 0; layer < mLayerCounts[level]; layer++) + { + ASSERT(mImageArray[level] != nullptr && mImageArray[level][layer] != nullptr); + if (mImageArray[level][layer]->isDirty()) + { + gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, layer); + gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1); + ANGLE_TRY(commitRegion(context, index, region)); + } + } + + return angle::Result::Continue; +} + +void TextureD3D_2DArray::deleteImages() +{ + for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level) + { + for (int layer = 0; layer < mLayerCounts[level]; ++layer) + { + delete mImageArray[level][layer]; + } + delete[] mImageArray[level]; + mImageArray[level] = nullptr; + mLayerCounts[level] = 0; + } +} + +angle::Result TextureD3D_2DArray::redefineImage(const gl::Context *context, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + // If there currently is a corresponding storage texture image, it has these parameters + const int storageWidth = std::max(1, getLevelZeroWidth() >> level); + const int storageHeight = std::max(1, getLevelZeroHeight() >> level); + const GLuint baseLevel = getBaseLevel(); + const GLenum storageFormat = getBaseLevelInternalFormat(); + + int storageDepth = 0; + if (baseLevel < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + storageDepth = getLayerCount(baseLevel); + } + + // Only reallocate the layers if the size doesn't match + if (size.depth != mLayerCounts[level]) + { + for (int layer = 0; layer < mLayerCounts[level]; layer++) + { + SafeDelete(mImageArray[level][layer]); + } + SafeDeleteArray(mImageArray[level]); + mLayerCounts[level] = size.depth; + + if (size.depth > 0) + { + mImageArray[level] = new ImageD3D *[size.depth]; + for (int layer = 0; layer < mLayerCounts[level]; layer++) + { + mImageArray[level][layer] = mRenderer->createImage(); + } + } + } + + if (mTexStorage) + { + const int storageLevels = mTexStorage->getLevelCount(); + + if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth || + size.height != storageHeight || size.depth != storageDepth || + internalformat != storageFormat) // Discard mismatched storage + { + markAllImagesDirty(); + + gl::TexLevelMask copyImageMask; + copyImageMask.set(); + copyImageMask.set(level, false); + + ANGLE_TRY(releaseTexStorage(context, copyImageMask)); + } + } + + if (size.depth > 0) + { + for (int layer = 0; layer < mLayerCounts[level]; layer++) + { + mImageArray[level][layer]->redefine(gl::TextureType::_2DArray, internalformat, + gl::Extents(size.width, size.height, 1), + forceRelease); + mDirtyImages = mDirtyImages || mImageArray[level][layer]->isDirty(); + } + } + + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_2DArray::imageIterator() const +{ + return gl::ImageIndexIterator::Make2DArray(0, mTexStorage->getLevelCount(), mLayerCounts); +} + +gl::ImageIndex TextureD3D_2DArray::getImageIndex(GLint mip, GLint layer) const +{ + return gl::ImageIndex::Make2DArray(mip, layer); +} + +bool TextureD3D_2DArray::isValidIndex(const gl::ImageIndex &index) const +{ + // Check for having a storage and the right type of index + if (!mTexStorage || index.getType() != gl::TextureType::_2DArray) + { + return false; + } + + // Check the mip index + if (index.getLevelIndex() < 0 || index.getLevelIndex() >= mTexStorage->getLevelCount()) + { + return false; + } + + // Check the layer index + return (!index.hasLayer() || (index.getLayerIndex() >= 0 && + index.getLayerIndex() < mLayerCounts[index.getLevelIndex()])); +} + +void TextureD3D_2DArray::markAllImagesDirty() +{ + for (int dirtyLevel = 0; dirtyLevel < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; dirtyLevel++) + { + for (int dirtyLayer = 0; dirtyLayer < mLayerCounts[dirtyLevel]; dirtyLayer++) + { + mImageArray[dirtyLevel][dirtyLayer]->markDirty(); + } + } + mDirtyImages = true; +} + +TextureD3DImmutableBase::TextureD3DImmutableBase(const gl::TextureState &state, + RendererD3D *renderer) + : TextureD3D(state, renderer) +{} + +TextureD3DImmutableBase::~TextureD3DImmutableBase() {} + +ImageD3D *TextureD3DImmutableBase::getImage(const gl::ImageIndex &index) const +{ + return nullptr; +} + +angle::Result TextureD3DImmutableBase::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::bindTexImage(const gl::Context *context, + egl::Surface *surface) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3DImmutableBase::releaseTexImage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +TextureD3D_External::TextureD3D_External(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3DImmutableBase(state, renderer) +{} + +TextureD3D_External::~TextureD3D_External() {} + +GLsizei TextureD3D_External::getLayerCount(int level) const +{ + return 1; +} + +angle::Result TextureD3D_External::setImageExternal(const gl::Context *context, + gl::TextureType type, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc) +{ + ASSERT(type == gl::TextureType::External); + + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + + // If the stream is null, the external image is unbound and we release the storage + if (stream != nullptr) + { + mTexStorage = mRenderer->createTextureStorageExternal(stream, desc, mState.getLabel()); + } + + return angle::Result::Continue; +} + +angle::Result TextureD3D_External::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + EGLImageD3D *eglImaged3d = GetImplAs<EGLImageD3D>(image); + + // Pass in the RenderTargetD3D here: createTextureStorage can't generate an error. + RenderTargetD3D *renderTargetD3D = nullptr; + ANGLE_TRY(eglImaged3d->getRenderTarget(context, &renderTargetD3D)); + + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + mTexStorage = + mRenderer->createTextureStorageEGLImage(eglImaged3d, renderTargetD3D, mState.getLabel()); + + return angle::Result::Continue; +} + +angle::Result TextureD3D_External::initMipmapImages(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Stop; +} + +angle::Result TextureD3D_External::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + UNREACHABLE(); + return angle::Result::Stop; +} + +bool TextureD3D_External::isImageComplete(const gl::ImageIndex &index) const +{ + return (index.getLevelIndex() == 0) ? (mTexStorage != nullptr) : false; +} + +angle::Result TextureD3D_External::initializeStorage(const gl::Context *context, + BindFlags bindFlags) +{ + // Texture storage is created when an external image is bound + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_External::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + UNREACHABLE(); + return angle::Result::Continue; +} + +angle::Result TextureD3D_External::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + UNREACHABLE(); + return angle::Result::Continue; +} + +angle::Result TextureD3D_External::updateStorage(const gl::Context *context) +{ + // Texture storage does not need to be updated since it is already loaded with the latest + // external image + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_External::imageIterator() const +{ + return gl::ImageIndexIterator::Make2D(0, mTexStorage->getLevelCount()); +} + +gl::ImageIndex TextureD3D_External::getImageIndex(GLint mip, GLint /*layer*/) const +{ + // "layer" does not apply to 2D Textures. + return gl::ImageIndex::Make2D(mip); +} + +bool TextureD3D_External::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::External && + index.getLevelIndex() == 0); +} + +void TextureD3D_External::markAllImagesDirty() +{ + UNREACHABLE(); +} + +TextureD3D_2DMultisample::TextureD3D_2DMultisample(const gl::TextureState &state, + RendererD3D *renderer) + : TextureD3DImmutableBase(state, renderer) +{} + +TextureD3D_2DMultisample::~TextureD3D_2DMultisample() {} + +angle::Result TextureD3D_2DMultisample::setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) +{ + ASSERT(type == gl::TextureType::_2DMultisample && size.depth == 1); + + // We allocate storage immediately instead of doing it lazily like other TextureD3D classes do. + // This requires less state in this class. + TexStoragePointer storage = {mRenderer->createTextureStorage2DMultisample( + internalformat, size.width, size.height, static_cast<int>(0), + samples, fixedSampleLocations, mState.getLabel()), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + mImmutable = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +gl::ImageIndexIterator TextureD3D_2DMultisample::imageIterator() const +{ + return gl::ImageIndexIterator::Make2DMultisample(); +} + +gl::ImageIndex TextureD3D_2DMultisample::getImageIndex(GLint mip, GLint layer) const +{ + return gl::ImageIndex::Make2DMultisample(); +} + +bool TextureD3D_2DMultisample::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::_2DMultisample && + index.getLevelIndex() == 0); +} + +GLsizei TextureD3D_2DMultisample::getLayerCount(int level) const +{ + return 1; +} + +void TextureD3D_2DMultisample::markAllImagesDirty() {} + +angle::Result TextureD3D_2DMultisample::initializeStorage(const gl::Context *context, + BindFlags bindFlags) +{ + // initializeStorage should only be called in a situation where the texture already has storage + // associated with it (storage is created in setStorageMultisample). + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + UNREACHABLE(); + *outStorage = {mTexStorage, context}; + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + // These textures are immutable, so this should only be ever called once. + ASSERT(!mTexStorage); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::updateStorage(const gl::Context *context) +{ + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisample::initMipmapImages(const gl::Context *context) +{ + UNREACHABLE(); + return angle::Result::Continue; +} + +bool TextureD3D_2DMultisample::isImageComplete(const gl::ImageIndex &index) const +{ + return true; +} + +TextureD3D_2DMultisampleArray::TextureD3D_2DMultisampleArray(const gl::TextureState &state, + RendererD3D *renderer) + : TextureD3DImmutableBase(state, renderer) +{} + +TextureD3D_2DMultisampleArray::~TextureD3D_2DMultisampleArray() {} + +angle::Result TextureD3D_2DMultisampleArray::setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) +{ + ASSERT(type == gl::TextureType::_2DMultisampleArray); + + mLayerCount = size.depth; + + TexStoragePointer storage = { + mRenderer->createTextureStorage2DMultisampleArray(internalformat, size.width, size.height, + size.depth, static_cast<int>(0), samples, + fixedSampleLocations, mState.getLabel()), + context}; + + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + + mImmutable = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + // ensure the underlying texture is created + ANGLE_TRY(ensureRenderTarget(context)); + + return mTexStorage->getRenderTarget(context, index, samples, outRT); +} + +gl::ImageIndexIterator TextureD3D_2DMultisampleArray::imageIterator() const +{ + return gl::ImageIndexIterator::Make2DMultisampleArray(&mLayerCount); +} + +gl::ImageIndex TextureD3D_2DMultisampleArray::getImageIndex(GLint mip, GLint layer) const +{ + return gl::ImageIndex::Make2DMultisampleArray(layer); +} + +bool TextureD3D_2DMultisampleArray::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::_2DMultisampleArray && + index.getLevelIndex() == 0); +} + +GLsizei TextureD3D_2DMultisampleArray::getLayerCount(int level) const +{ + return mLayerCount; +} + +void TextureD3D_2DMultisampleArray::markAllImagesDirty() {} + +angle::Result TextureD3D_2DMultisampleArray::initializeStorage(const gl::Context *context, + BindFlags bindFlags) +{ + // initializeStorage should only be called in a situation where the texture already has storage + // associated with it (storage is created in setStorageMultisample). + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::createCompleteStorage( + const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + UNREACHABLE(); + *outStorage = {mTexStorage, context}; + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::setCompleteTexStorage( + const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + // These textures are immutable, so this should only be ever called once. + ASSERT(!mTexStorage); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::updateStorage(const gl::Context *context) +{ + return angle::Result::Continue; +} + +angle::Result TextureD3D_2DMultisampleArray::initMipmapImages(const gl::Context *context) +{ + UNIMPLEMENTED(); + return angle::Result::Continue; +} + +bool TextureD3D_2DMultisampleArray::isImageComplete(const gl::ImageIndex &index) const +{ + return true; +} + +TextureD3D_Buffer::TextureD3D_Buffer(const gl::TextureState &state, RendererD3D *renderer) + : TextureD3D(state, renderer), mInternalFormat(GL_INVALID_ENUM) +{} + +TextureD3D_Buffer::~TextureD3D_Buffer() {} + +angle::Result TextureD3D_Buffer::setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::bindTexImage(const gl::Context *context, egl::Surface *surface) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::releaseTexImage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +GLsizei TextureD3D_Buffer::getLayerCount(int level) const +{ + return 1; +} + +angle::Result TextureD3D_Buffer::initMipmapImages(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Stop; +} + +bool TextureD3D_Buffer::isImageComplete(const gl::ImageIndex &index) const +{ + return (index.getLevelIndex() == 0) ? (mTexStorage != nullptr) : false; +} + +angle::Result TextureD3D_Buffer::initializeStorage(const gl::Context *context, BindFlags bindFlags) +{ + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) +{ + ANGLE_TRY(releaseTexStorage(context, gl::TexLevelMask())); + mTexStorage = newCompleteTexStorage; + mTexStorageObserverBinding.bind(mTexStorage); + + mDirtyImages = true; + + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::updateStorage(const gl::Context *context) +{ + ASSERT(mTexStorage); + return angle::Result::Continue; +} + +gl::ImageIndexIterator TextureD3D_Buffer::imageIterator() const +{ + return gl::ImageIndexIterator::MakeBuffer(); +} + +gl::ImageIndex TextureD3D_Buffer::getImageIndex(GLint mip, GLint layer) const +{ + return gl::ImageIndex::MakeBuffer(); +} + +bool TextureD3D_Buffer::isValidIndex(const gl::ImageIndex &index) const +{ + return (mTexStorage && index.getType() == gl::TextureType::Buffer && + index.getLevelIndex() == 0); +} + +void TextureD3D_Buffer::markAllImagesDirty() +{ + UNREACHABLE(); +} + +angle::Result TextureD3D_Buffer::setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<ContextD3D>(context)); + return angle::Result::Continue; +} + +ImageD3D *TextureD3D_Buffer::getImage(const gl::ImageIndex &index) const +{ + return nullptr; +} + +angle::Result TextureD3D_Buffer::setBuffer(const gl::Context *context, GLenum internalFormat) +{ + ASSERT(mState.getType() == gl::TextureType::Buffer); + TexStoragePointer storage; + storage.reset(mRenderer->createTextureStorageBuffer(mState.getBuffer(), internalFormat, + mState.getLabel())); + ANGLE_TRY(setCompleteTexStorage(context, storage.get())); + storage.release(); + mInternalFormat = internalFormat; + mImmutable = false; + return angle::Result::Continue; +} + +angle::Result TextureD3D_Buffer::syncState(const gl::Context *context, + const gl::Texture::DirtyBits &dirtyBits, + gl::Command source) +{ + ASSERT(mState.getType() == gl::TextureType::Buffer); + if (dirtyBits.test(gl::Texture::DirtyBitType::DIRTY_BIT_IMPLEMENTATION) && + mState.getBuffer().get() != nullptr) + { + // buffer data have been changed. Buffer data may out of sync + // give up the old TexStorage, create a new one. + // this may not efficient, since staging buffer may be patially updated. + ANGLE_TRY(setBuffer(context, mInternalFormat)); + } + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.h new file mode 100644 index 0000000000..a87806b3e7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureD3D.h @@ -0,0 +1,1050 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureD3D.h: Implementations of the Texture interfaces shared betweeen the D3D backends. + +#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" +#include "libANGLE/renderer/TextureImpl.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/TextureStorage.h" + +namespace gl +{ +class Framebuffer; +} + +namespace rx +{ +class EGLImageD3D; +class ImageD3D; +class RendererD3D; +class RenderTargetD3D; +class TextureStorage; + +class TextureD3D : public TextureImpl, public angle::ObserverInterface +{ + public: + TextureD3D(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D() override; + + void onDestroy(const gl::Context *context) override; + + angle::Result getNativeTexture(const gl::Context *context, TextureStorage **outStorage); + + bool hasDirtyImages() const { return mDirtyImages; } + void resetDirty() { mDirtyImages = false; } + + virtual ImageD3D *getImage(const gl::ImageIndex &index) const = 0; + virtual GLsizei getLayerCount(int level) const = 0; + + angle::Result getImageAndSyncFromStorage(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D **outImage); + + GLint getBaseLevelWidth() const; + GLint getBaseLevelHeight() const; + GLenum getBaseLevelInternalFormat() const; + + angle::Result setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) override; + + angle::Result setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) override; + + angle::Result setBuffer(const gl::Context *context, GLenum internalFormat) override; + + angle::Result setStorageExternalMemory(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size, + gl::MemoryObject *memoryObject, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) override; + + bool isImmutable() const { return mImmutable; } + + virtual angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) = 0; + + // Returns an iterator over all "Images" for this particular Texture. + virtual gl::ImageIndexIterator imageIterator() const = 0; + + // Returns an ImageIndex for a particular "Image". 3D Textures do not have images for + // slices of their depth texures, so 3D textures ignore the layer parameter. + virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const = 0; + virtual bool isValidIndex(const gl::ImageIndex &index) const = 0; + + angle::Result setImageExternal(const gl::Context *context, + gl::TextureType type, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc) override; + angle::Result generateMipmap(const gl::Context *context) override; + bool hasStorage() const { return mTexStorage != nullptr; } + TextureStorage *getStorage(); + ImageD3D *getBaseLevelImage() const; + + angle::Result getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) override; + + angle::Result setBaseLevel(const gl::Context *context, GLuint baseLevel) override; + + angle::Result syncState(const gl::Context *context, + const gl::Texture::DirtyBits &dirtyBits, + gl::Command source) override; + + angle::Result initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) override; + + GLsizei getRenderToTextureSamples(); + + angle::Result ensureUnorderedAccess(const gl::Context *context); + angle::Result onLabelUpdate(const gl::Context *context) override; + + // ObserverInterface implementation. + void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override; + + protected: + angle::Result setImageImpl(const gl::Context *context, + const gl::ImageIndex &index, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + ptrdiff_t layerOffset); + angle::Result subImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + ptrdiff_t layerOffset); + angle::Result setCompressedImageImpl(const gl::Context *context, + const gl::ImageIndex &index, + const gl::PixelUnpackState &unpack, + const uint8_t *pixels, + ptrdiff_t layerOffset); + angle::Result subImageCompressed(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + const uint8_t *pixels, + ptrdiff_t layerOffset); + bool isFastUnpackable(const gl::Buffer *unpackBuffer, + const gl::PixelUnpackState &unpack, + GLenum sizedInternalFormat); + angle::Result fastUnpackPixels(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels, + const gl::Box &destArea, + GLenum sizedInternalFormat, + GLenum type, + RenderTargetD3D *destRenderTarget); + + GLint getLevelZeroWidth() const; + GLint getLevelZeroHeight() const; + virtual GLint getLevelZeroDepth() const; + + GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const; + virtual angle::Result initMipmapImages(const gl::Context *context) = 0; + bool isBaseImageZeroSize() const; + virtual bool isImageComplete(const gl::ImageIndex &index) const = 0; + + bool canCreateRenderTargetForImage(const gl::ImageIndex &index) const; + angle::Result ensureBindFlags(const gl::Context *context, BindFlags bindFlags); + angle::Result ensureRenderTarget(const gl::Context *context); + + virtual angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const = 0; + virtual angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) = 0; + angle::Result commitRegion(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box ®ion); + + angle::Result releaseTexStorage(const gl::Context *context, + const gl::TexLevelMask ©StorageToImagesMask); + + GLuint getBaseLevel() const { return mBaseLevel; } + + virtual void markAllImagesDirty() = 0; + + GLint getBaseLevelDepth() const; + + RendererD3D *mRenderer; + + bool mDirtyImages; + + bool mImmutable; + TextureStorage *mTexStorage; + angle::ObserverBinding mTexStorageObserverBinding; + + private: + virtual angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) = 0; + + virtual angle::Result updateStorage(const gl::Context *context) = 0; + + bool couldUseSetData() const; + bool shouldUseSetData(const ImageD3D *image) const; + + angle::Result generateMipmapUsingImages(const gl::Context *context, const GLuint maxLevel); + + GLuint mBaseLevel; +}; + +class TextureD3D_2D : public TextureD3D +{ + public: + TextureD3D_2D(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_2D() override; + + void onDestroy(const gl::Context *context) override; + + ImageD3D *getImage(int level, int layer) const; + ImageD3D *getImage(const gl::ImageIndex &index) const override; + GLsizei getLayerCount(int level) const override; + + GLsizei getWidth(GLint level) const; + GLsizei getHeight(GLint level) const; + GLenum getInternalFormat(GLint level) const; + bool isDepth(GLint level) const; + bool isSRGB(GLint level) const; + + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + angle::Result copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + angle::Result copyCompressedTexture(const gl::Context *context, + const gl::Texture *source) override; + + angle::Result setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isValidLevel(int level) const; + bool isLevelComplete(int level) const; + bool isImageComplete(const gl::ImageIndex &index) const override; + + angle::Result updateStorageLevel(const gl::Context *context, int level); + + angle::Result redefineImage(const gl::Context *context, + size_t level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease); + + bool mEGLImageTarget; + gl::TexLevelArray<std::unique_ptr<ImageD3D>> mImageArray; +}; + +class TextureD3D_Cube : public TextureD3D +{ + public: + TextureD3D_Cube(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_Cube() override; + + void onDestroy(const gl::Context *context) override; + + ImageD3D *getImage(int level, int layer) const; + ImageD3D *getImage(const gl::ImageIndex &index) const override; + GLsizei getLayerCount(int level) const override; + + GLenum getInternalFormat(GLint level, GLint layer) const; + bool isDepth(GLint level, GLint layer) const; + bool isSRGB(GLint level, GLint layer) const; + + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + angle::Result copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + + angle::Result setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isValidFaceLevel(int faceIndex, int level) const; + bool isFaceLevelComplete(int faceIndex, int level) const; + bool isCubeComplete() const; + bool isImageComplete(const gl::ImageIndex &index) const override; + angle::Result updateStorageFaceLevel(const gl::Context *context, int faceIndex, int level); + + angle::Result redefineImage(const gl::Context *context, + int faceIndex, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease); + + std::array<gl::TexLevelArray<std::unique_ptr<ImageD3D>>, 6> mImageArray; +}; + +class TextureD3D_3D : public TextureD3D +{ + public: + TextureD3D_3D(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_3D() override; + + void onDestroy(const gl::Context *context) override; + + ImageD3D *getImage(int level, int layer) const; + ImageD3D *getImage(const gl::ImageIndex &index) const override; + GLsizei getLayerCount(int level) const override; + + GLsizei getWidth(GLint level) const; + GLsizei getHeight(GLint level) const; + GLsizei getDepth(GLint level) const; + GLenum getInternalFormat(GLint level) const; + bool isDepth(GLint level) const; + bool isSRGB(GLint level) const; + + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + angle::Result copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + + angle::Result setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + GLint getLevelZeroDepth() const override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isValidLevel(int level) const; + bool isLevelComplete(int level) const; + bool isImageComplete(const gl::ImageIndex &index) const override; + angle::Result updateStorageLevel(const gl::Context *context, int level); + + angle::Result redefineImage(const gl::Context *context, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease); + + gl::TexLevelArray<std::unique_ptr<ImageD3D>> mImageArray; +}; + +class TextureD3D_2DArray : public TextureD3D +{ + public: + TextureD3D_2DArray(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_2DArray() override; + + void onDestroy(const gl::Context *context) override; + + virtual ImageD3D *getImage(int level, int layer) const; + ImageD3D *getImage(const gl::ImageIndex &index) const override; + GLsizei getLayerCount(int level) const override; + + GLsizei getWidth(GLint level) const; + GLsizei getHeight(GLint level) const; + GLenum getInternalFormat(GLint level) const; + bool isDepth(GLint level) const; + + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + GLenum type, + GLint sourceLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + angle::Result copySubTexture(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + GLint sourceLevel, + const gl::Box &sourceBox, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const gl::Texture *source) override; + + angle::Result setStorage(const gl::Context *context, + gl::TextureType type, + size_t levels, + GLenum internalFormat, + const gl::Extents &size) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isValidLevel(int level) const; + bool isLevelComplete(int level) const; + bool isImageComplete(const gl::ImageIndex &index) const override; + bool isSRGB(GLint level) const; + angle::Result updateStorageLevel(const gl::Context *context, int level); + + void deleteImages(); + angle::Result redefineImage(const gl::Context *context, + GLint level, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease); + + // Storing images as an array of single depth textures since D3D11 treats each array level of a + // Texture2D object as a separate subresource. Each layer would have to be looped over + // to update all the texture layers since they cannot all be updated at once and it makes the + // most sense for the Image class to not have to worry about layer subresource as well as mip + // subresources. + GLsizei mLayerCounts[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS]; + ImageD3D **mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS]; +}; + +// Base class for immutable textures. These don't support manipulation of individual texture images. +class TextureD3DImmutableBase : public TextureD3D +{ + public: + TextureD3DImmutableBase(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3DImmutableBase() override; + + ImageD3D *getImage(const gl::ImageIndex &index) const override; + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; +}; + +class TextureD3D_External : public TextureD3DImmutableBase +{ + public: + TextureD3D_External(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_External() override; + + GLsizei getLayerCount(int level) const override; + + angle::Result setImageExternal(const gl::Context *context, + gl::TextureType type, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isImageComplete(const gl::ImageIndex &index) const override; +}; + +class TextureD3D_2DMultisample : public TextureD3DImmutableBase +{ + public: + TextureD3D_2DMultisample(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_2DMultisample() override; + + angle::Result setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + GLsizei getLayerCount(int level) const override; + + protected: + void markAllImagesDirty() override; + + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isImageComplete(const gl::ImageIndex &index) const override; +}; + +class TextureD3D_2DMultisampleArray : public TextureD3DImmutableBase +{ + public: + TextureD3D_2DMultisampleArray(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_2DMultisampleArray() override; + + angle::Result setStorageMultisample(const gl::Context *context, + gl::TextureType type, + GLsizei samples, + GLint internalformat, + const gl::Extents &size, + bool fixedSampleLocations) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + GLsizei getLayerCount(int level) const override; + + protected: + void markAllImagesDirty() override; + + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isImageComplete(const gl::ImageIndex &index) const override; + + GLsizei mLayerCount; +}; + +class TextureD3D_Buffer : public TextureD3D +{ + public: + TextureD3D_Buffer(const gl::TextureState &data, RendererD3D *renderer); + ~TextureD3D_Buffer() override; + + ImageD3D *getImage(const gl::ImageIndex &index) const override; + + angle::Result setBuffer(const gl::Context *context, GLenum internalFormat) override; + + angle::Result setImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + angle::Result setSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + GLenum type, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + const uint8_t *pixels) override; + + angle::Result setCompressedImage(const gl::Context *context, + const gl::ImageIndex &index, + GLenum internalFormat, + const gl::Extents &size, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + angle::Result setCompressedSubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Box &area, + GLenum format, + const gl::PixelUnpackState &unpack, + size_t imageSize, + const uint8_t *pixels) override; + + angle::Result copyImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Rectangle &sourceArea, + GLenum internalFormat, + gl::Framebuffer *source) override; + angle::Result copySubImage(const gl::Context *context, + const gl::ImageIndex &index, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + gl::Framebuffer *source) override; + + angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override; + angle::Result releaseTexImage(const gl::Context *context) override; + + angle::Result setEGLImageTarget(const gl::Context *context, + gl::TextureType type, + egl::Image *image) override; + + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + GLsizei getLayerCount(int level) const override; + + angle::Result syncState(const gl::Context *context, + const gl::Texture::DirtyBits &dirtyBits, + gl::Command source) override; + + gl::ImageIndexIterator imageIterator() const override; + gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override; + bool isValidIndex(const gl::ImageIndex &index) const override; + + protected: + void markAllImagesDirty() override; + + private: + angle::Result initializeStorage(const gl::Context *context, BindFlags bindFlags) override; + angle::Result createCompleteStorage(const gl::Context *context, + BindFlags bindFlags, + TexStoragePointer *outTexStorage) const override; + angle::Result setCompleteTexStorage(const gl::Context *context, + TextureStorage *newCompleteTexStorage) override; + + angle::Result updateStorage(const gl::Context *context) override; + angle::Result initMipmapImages(const gl::Context *context) override; + + bool isImageComplete(const gl::ImageIndex &index) const override; + + GLenum mInternalFormat; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_TEXTURED3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureStorage.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureStorage.h new file mode 100644 index 0000000000..fc073f8b5a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/TextureStorage.h @@ -0,0 +1,135 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureStorage.h: Defines the abstract rx::TextureStorage class. + +#ifndef LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_ +#define LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_ + +#include "common/debug.h" +#include "libANGLE/angletypes.h" + +#include <GLES2/gl2.h> +#include <stdint.h> + +namespace gl +{ +class Context; +class ImageIndex; +struct Box; +struct PixelUnpackState; +} // namespace gl + +namespace angle +{ +class Subject; +} // namespace angle + +namespace rx +{ +class SwapChainD3D; +class RenderTargetD3D; +class ImageD3D; + +// Dirty bit messages from TextureStorage +constexpr size_t kTextureStorageObserverMessageIndex = 0; + +class TextureStorage : public angle::Subject +{ + public: + TextureStorage(const std::string &label) : mKHRDebugLabel(label) {} + ~TextureStorage() override {} + + virtual angle::Result onDestroy(const gl::Context *context); + + virtual int getTopLevel() const = 0; + virtual bool isRenderTarget() const = 0; + virtual bool isUnorderedAccess() const = 0; + virtual bool isManaged() const = 0; + virtual bool supportsNativeMipmapFunction() const = 0; + virtual int getLevelCount() const = 0; + + virtual angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const = 0; + virtual angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) = 0; + virtual angle::Result generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) = 0; + + virtual angle::Result copyToStorage(const gl::Context *context, + TextureStorage *destStorage) = 0; + virtual angle::Result setData(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D *image, + const gl::Box *destBox, + GLenum type, + const gl::PixelUnpackState &unpack, + const uint8_t *pixelData) = 0; + + // This is a no-op for most implementations of TextureStorage. Some (e.g. TextureStorage11_2D) + // might override it. + virtual angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture); + + virtual void invalidateTextures() {} + + // RenderToTexture methods + virtual angle::Result releaseMultisampledTexStorageForLevel(size_t level); + virtual angle::Result resolveTexture(const gl::Context *context); + virtual GLsizei getRenderToTextureSamples() const; + + // Called by outer object when label has changed via KHR_debug extension + void setLabel(const std::string &newLabel); + + protected: + virtual void onLabelUpdate() {} + + const angle::Subject *mSubject; + std::string mKHRDebugLabel; +}; + +inline angle::Result TextureStorage::onDestroy(const gl::Context *context) +{ + return angle::Result::Continue; +} + +inline angle::Result TextureStorage::useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) +{ + return angle::Result::Continue; +} + +inline angle::Result TextureStorage::releaseMultisampledTexStorageForLevel(size_t level) +{ + return angle::Result::Continue; +} + +inline angle::Result TextureStorage::resolveTexture(const gl::Context *context) +{ + return angle::Result::Continue; +} + +inline GLsizei TextureStorage::getRenderToTextureSamples() const +{ + return 0; +} + +inline void TextureStorage::setLabel(const std::string &newLabel) +{ + mKHRDebugLabel = newLabel; + onLabelUpdate(); +} + +using TexStoragePointer = angle::UniqueObjectPointer<TextureStorage, gl::Context>; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.cpp new file mode 100644 index 0000000000..acb27adfcc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.cpp @@ -0,0 +1,308 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer.cpp: Defines the abstract VertexBuffer class and VertexBufferInterface +// class with derivations, classes that perform graphics API agnostic vertex buffer operations. + +#include "libANGLE/renderer/d3d/VertexBuffer.h" + +#include "common/mathutil.h" +#include "libANGLE/Context.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" + +namespace rx +{ + +// VertexBuffer Implementation +unsigned int VertexBuffer::mNextSerial = 1; + +VertexBuffer::VertexBuffer() : mRefCount(1) +{ + updateSerial(); +} + +VertexBuffer::~VertexBuffer() {} + +void VertexBuffer::updateSerial() +{ + mSerial = mNextSerial++; +} + +unsigned int VertexBuffer::getSerial() const +{ + return mSerial; +} + +void VertexBuffer::addRef() +{ + mRefCount++; +} + +void VertexBuffer::release() +{ + ASSERT(mRefCount > 0); + mRefCount--; + + if (mRefCount == 0) + { + delete this; + } +} + +// VertexBufferInterface Implementation +VertexBufferInterface::VertexBufferInterface(BufferFactoryD3D *factory, bool dynamic) + : mFactory(factory), mVertexBuffer(factory->createVertexBuffer()), mDynamic(dynamic) +{} + +VertexBufferInterface::~VertexBufferInterface() +{ + if (mVertexBuffer) + { + mVertexBuffer->release(); + mVertexBuffer = nullptr; + } +} + +unsigned int VertexBufferInterface::getSerial() const +{ + ASSERT(mVertexBuffer); + return mVertexBuffer->getSerial(); +} + +unsigned int VertexBufferInterface::getBufferSize() const +{ + ASSERT(mVertexBuffer); + return mVertexBuffer->getBufferSize(); +} + +angle::Result VertexBufferInterface::setBufferSize(const gl::Context *context, unsigned int size) +{ + ASSERT(mVertexBuffer); + if (mVertexBuffer->getBufferSize() == 0) + { + return mVertexBuffer->initialize(context, size, mDynamic); + } + + return mVertexBuffer->setBufferSize(context, size); +} + +angle::Result VertexBufferInterface::getSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *spaceInBytesOut) const +{ + unsigned int spaceRequired = 0; + ANGLE_TRY(mFactory->getVertexSpaceRequired(context, attrib, binding, count, instances, + baseInstance, &spaceRequired)); + + // Align to 16-byte boundary + unsigned int alignedSpaceRequired = roundUpPow2(spaceRequired, 16u); + ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextD3D>(context), alignedSpaceRequired >= spaceRequired); + + *spaceInBytesOut = alignedSpaceRequired; + return angle::Result::Continue; +} + +angle::Result VertexBufferInterface::discard(const gl::Context *context) +{ + ASSERT(mVertexBuffer); + return mVertexBuffer->discard(context); +} + +VertexBuffer *VertexBufferInterface::getVertexBuffer() const +{ + ASSERT(mVertexBuffer); + return mVertexBuffer; +} + +// StreamingVertexBufferInterface Implementation +StreamingVertexBufferInterface::StreamingVertexBufferInterface(BufferFactoryD3D *factory) + : VertexBufferInterface(factory, true), mWritePosition(0), mReservedSpace(0) +{} + +angle::Result StreamingVertexBufferInterface::initialize(const gl::Context *context, + std::size_t initialSize) +{ + return setBufferSize(context, static_cast<unsigned int>(initialSize)); +} + +void StreamingVertexBufferInterface::reset() +{ + if (mVertexBuffer) + { + mVertexBuffer->release(); + mVertexBuffer = mFactory->createVertexBuffer(); + } +} + +StreamingVertexBufferInterface::~StreamingVertexBufferInterface() {} + +angle::Result StreamingVertexBufferInterface::reserveSpace(const gl::Context *context, + unsigned int size) +{ + unsigned int curBufferSize = getBufferSize(); + if (size > curBufferSize) + { + ANGLE_TRY(setBufferSize(context, std::max(size, 3 * curBufferSize / 2))); + mWritePosition = 0; + } + else if (mWritePosition + size > curBufferSize) + { + ANGLE_TRY(discard(context)); + mWritePosition = 0; + } + + mReservedSpace = size; + return angle::Result::Continue; +} + +angle::Result StreamingVertexBufferInterface::storeDynamicAttribute( + const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *outStreamOffset, + const uint8_t *sourceData) +{ + unsigned int spaceRequired = 0; + ANGLE_TRY( + getSpaceRequired(context, attrib, binding, count, instances, baseInstance, &spaceRequired)); + + // Protect against integer overflow + angle::CheckedNumeric<unsigned int> checkedPosition(mWritePosition); + checkedPosition += spaceRequired; + ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextD3D>(context), checkedPosition.IsValid()); + + mReservedSpace = 0; + + size_t adjustedCount = count; + GLuint divisor = binding.getDivisor(); + + if (instances != 0 && divisor != 0) + { + // The attribute is an instanced attribute and it's an draw instance call + // Extra number of elements are copied at the beginning to make sure + // the driver is referencing the correct data with non-zero baseInstance + adjustedCount += UnsignedCeilDivide(baseInstance, divisor); + } + + ANGLE_TRY(mVertexBuffer->storeVertexAttributes(context, attrib, binding, currentValueType, + start, adjustedCount, instances, mWritePosition, + sourceData)); + + if (outStreamOffset) + { + *outStreamOffset = mWritePosition; + } + + mWritePosition += spaceRequired; + + return angle::Result::Continue; +} + +angle::Result StreamingVertexBufferInterface::reserveVertexSpace(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance) +{ + unsigned int requiredSpace = 0; + ANGLE_TRY(mFactory->getVertexSpaceRequired(context, attrib, binding, count, instances, + baseInstance, &requiredSpace)); + + // Align to 16-byte boundary + auto alignedRequiredSpace = rx::CheckedRoundUp(requiredSpace, 16u); + alignedRequiredSpace += mReservedSpace; + + // Protect against integer overflow + ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextD3D>(context), alignedRequiredSpace.IsValid()); + + ANGLE_TRY(reserveSpace(context, alignedRequiredSpace.ValueOrDie())); + + return angle::Result::Continue; +} + +// StaticVertexBufferInterface Implementation +StaticVertexBufferInterface::AttributeSignature::AttributeSignature() + : formatID(angle::FormatID::NONE), stride(0), offset(0) +{} + +bool StaticVertexBufferInterface::AttributeSignature::matchesAttribute( + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) const +{ + size_t attribStride = ComputeVertexAttributeStride(attrib, binding); + + if (formatID != attrib.format->id || static_cast<GLuint>(stride) != attribStride) + { + return false; + } + + size_t attribOffset = + (static_cast<size_t>(ComputeVertexAttributeOffset(attrib, binding)) % attribStride); + return (offset == attribOffset); +} + +void StaticVertexBufferInterface::AttributeSignature::set(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) +{ + formatID = attrib.format->id; + offset = stride = static_cast<GLuint>(ComputeVertexAttributeStride(attrib, binding)); + offset = static_cast<size_t>(ComputeVertexAttributeOffset(attrib, binding)) % + ComputeVertexAttributeStride(attrib, binding); +} + +StaticVertexBufferInterface::StaticVertexBufferInterface(BufferFactoryD3D *factory) + : VertexBufferInterface(factory, false) +{} + +StaticVertexBufferInterface::~StaticVertexBufferInterface() {} + +bool StaticVertexBufferInterface::matchesAttribute(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) const +{ + return mSignature.matchesAttribute(attrib, binding); +} + +void StaticVertexBufferInterface::setAttribute(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) +{ + return mSignature.set(attrib, binding); +} + +angle::Result StaticVertexBufferInterface::storeStaticAttribute(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + GLint start, + GLsizei count, + GLsizei instances, + const uint8_t *sourceData) +{ + unsigned int spaceRequired = 0; + ANGLE_TRY(getSpaceRequired(context, attrib, binding, count, instances, 0, &spaceRequired)); + ANGLE_TRY(setBufferSize(context, spaceRequired)); + + ASSERT(attrib.enabled); + ANGLE_TRY(mVertexBuffer->storeVertexAttributes(context, attrib, binding, + gl::VertexAttribType::InvalidEnum, start, count, + instances, 0, sourceData)); + + mSignature.set(attrib, binding); + mVertexBuffer->hintUnmapResource(); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.h new file mode 100644 index 0000000000..45a16c6bf5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexBuffer.h @@ -0,0 +1,189 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer.h: Defines the abstract VertexBuffer class and VertexBufferInterface +// class with derivations, classes that perform graphics API agnostic vertex buffer operations. + +#ifndef LIBANGLE_RENDERER_D3D_VERTEXBUFFER_H_ +#define LIBANGLE_RENDERER_D3D_VERTEXBUFFER_H_ + +#include "common/PackedEnums.h" +#include "common/angleutils.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/Format.h" + +#include <GLES2/gl2.h> + +#include <cstddef> +#include <cstdint> +#include <vector> + +namespace gl +{ +class Context; +struct VertexAttribute; +class VertexBinding; +struct VertexAttribCurrentValueData; +} // namespace gl + +namespace rx +{ +class BufferFactoryD3D; + +// Use a ref-counting scheme with self-deletion on release. We do this so that we can more +// easily manage the static buffer cache, without deleting currently bound buffers. +class VertexBuffer : angle::NonCopyable +{ + public: + VertexBuffer(); + + virtual angle::Result initialize(const gl::Context *context, + unsigned int size, + bool dynamicUsage) = 0; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + virtual angle::Result storeVertexAttributes(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + unsigned int offset, + const uint8_t *sourceData) = 0; + + virtual unsigned int getBufferSize() const = 0; + virtual angle::Result setBufferSize(const gl::Context *context, unsigned int size) = 0; + virtual angle::Result discard(const gl::Context *context) = 0; + + unsigned int getSerial() const; + + // This may be overridden (e.g. by VertexBuffer11) if necessary. + virtual void hintUnmapResource() {} + + // Reference counting. + void addRef(); + void release(); + + protected: + void updateSerial(); + virtual ~VertexBuffer(); + + private: + unsigned int mSerial; + static unsigned int mNextSerial; + unsigned int mRefCount; +}; + +class VertexBufferInterface : angle::NonCopyable +{ + public: + VertexBufferInterface(BufferFactoryD3D *factory, bool dynamic); + virtual ~VertexBufferInterface(); + + unsigned int getBufferSize() const; + bool empty() const { return getBufferSize() == 0; } + + unsigned int getSerial() const; + + VertexBuffer *getVertexBuffer() const; + + protected: + angle::Result discard(const gl::Context *context); + + angle::Result setBufferSize(const gl::Context *context, unsigned int size); + + angle::Result getSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *spaceInBytesOut) const; + BufferFactoryD3D *const mFactory; + VertexBuffer *mVertexBuffer; + bool mDynamic; +}; + +class StreamingVertexBufferInterface : public VertexBufferInterface +{ + public: + StreamingVertexBufferInterface(BufferFactoryD3D *factory); + ~StreamingVertexBufferInterface() override; + + angle::Result initialize(const gl::Context *context, std::size_t initialSize); + void reset(); + + angle::Result storeDynamicAttribute(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *outStreamOffset, + const uint8_t *sourceData); + + angle::Result reserveVertexSpace(const gl::Context *context, + const gl::VertexAttribute &attribute, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance); + + private: + angle::Result reserveSpace(const gl::Context *context, unsigned int size); + + unsigned int mWritePosition; + unsigned int mReservedSpace; +}; + +class StaticVertexBufferInterface : public VertexBufferInterface +{ + public: + explicit StaticVertexBufferInterface(BufferFactoryD3D *factory); + ~StaticVertexBufferInterface() override; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using these + // functions. + angle::Result storeStaticAttribute(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + GLint start, + GLsizei count, + GLsizei instances, + const uint8_t *sourceData); + + bool matchesAttribute(const gl::VertexAttribute &attribute, + const gl::VertexBinding &binding) const; + + void setAttribute(const gl::VertexAttribute &attribute, const gl::VertexBinding &binding); + + private: + class AttributeSignature final : angle::NonCopyable + { + public: + AttributeSignature(); + + bool matchesAttribute(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) const; + + void set(const gl::VertexAttribute &attrib, const gl::VertexBinding &binding); + + private: + angle::FormatID formatID; + GLuint stride; + size_t offset; + }; + + AttributeSignature mSignature; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_VERTEXBUFFER_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.cpp new file mode 100644 index 0000000000..6b989c9e80 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.cpp @@ -0,0 +1,683 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexDataManager.h: Defines the VertexDataManager, a class that +// runs the Buffer translation process. + +#include "libANGLE/renderer/d3d/VertexDataManager.h" + +#include "common/bitset_utils.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/Program.h" +#include "libANGLE/State.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" +#include "libANGLE/renderer/d3d/VertexBuffer.h" + +using namespace angle; + +namespace rx +{ +namespace +{ +enum +{ + INITIAL_STREAM_BUFFER_SIZE = 1024 * 1024 +}; +// This has to be at least 4k or else it fails on ATI cards. +enum +{ + CONSTANT_VERTEX_BUFFER_SIZE = 4096 +}; + +// Warning: ensure the binding matches attrib.bindingIndex before using these functions. +int64_t GetMaxAttributeByteOffsetForDraw(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + int64_t elementCount) +{ + CheckedNumeric<int64_t> stride = ComputeVertexAttributeStride(attrib, binding); + CheckedNumeric<int64_t> offset = ComputeVertexAttributeOffset(attrib, binding); + CheckedNumeric<int64_t> size = ComputeVertexAttributeTypeSize(attrib); + + ASSERT(elementCount > 0); + + CheckedNumeric<int64_t> result = + stride * (CheckedNumeric<int64_t>(elementCount) - 1) + size + offset; + return result.ValueOrDefault(std::numeric_limits<int64_t>::max()); +} + +// Warning: ensure the binding matches attrib.bindingIndex before using these functions. +int ElementsInBuffer(const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + unsigned int size) +{ + angle::CheckedNumeric<int64_t> bufferSize(size); + angle::CheckedNumeric<int64_t> stride = ComputeVertexAttributeStride(attrib, binding); + angle::CheckedNumeric<int64_t> offset = ComputeVertexAttributeOffset(attrib, binding); + angle::CheckedNumeric<int64_t> elementSize = ComputeVertexAttributeTypeSize(attrib); + + auto elementsInBuffer = (bufferSize - (offset % stride) + (stride - elementSize)) / stride; + auto elementsInBufferInt = elementsInBuffer.Cast<int>(); + + return elementsInBufferInt.ValueOrDefault(0); +} + +// Warning: you should ensure binding really matches attrib.bindingIndex before using this function. +bool DirectStoragePossible(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) +{ + // Current value attribs may not use direct storage. + if (!attrib.enabled) + { + return false; + } + + gl::Buffer *buffer = binding.getBuffer().get(); + if (!buffer) + { + return false; + } + + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + ASSERT(bufferD3D); + if (!bufferD3D->supportsDirectBinding()) + { + return false; + } + + // Alignment restrictions: In D3D, vertex data must be aligned to the format stride, or to a + // 4-byte boundary, whichever is smaller. (Undocumented, and experimentally confirmed) + size_t alignment = 4; + + // TODO(jmadill): add VertexFormatCaps + BufferFactoryD3D *factory = bufferD3D->getFactory(); + + angle::FormatID vertexFormatID = attrib.format->id; + + // CPU-converted vertex data must be converted (naturally). + if ((factory->getVertexConversionType(vertexFormatID) & VERTEX_CONVERT_CPU) != 0) + { + return false; + } + + if (attrib.format->vertexAttribType != gl::VertexAttribType::Float) + { + unsigned int elementSize = 0; + angle::Result error = + factory->getVertexSpaceRequired(context, attrib, binding, 1, 0, 0, &elementSize); + ASSERT(error == angle::Result::Continue); + alignment = std::min<size_t>(elementSize, 4); + } + + GLintptr offset = ComputeVertexAttributeOffset(attrib, binding); + // Final alignment check - unaligned data must be converted. + return (static_cast<size_t>(ComputeVertexAttributeStride(attrib, binding)) % alignment == 0) && + (static_cast<size_t>(offset) % alignment == 0); +} +} // anonymous namespace + +TranslatedAttribute::TranslatedAttribute() + : active(false), + attribute(nullptr), + binding(nullptr), + currentValueType(gl::VertexAttribType::InvalidEnum), + baseOffset(0), + usesFirstVertexOffset(false), + stride(0), + vertexBuffer(), + storage(nullptr), + serial(0), + divisor(0) +{} + +TranslatedAttribute::TranslatedAttribute(const TranslatedAttribute &other) = default; + +angle::Result TranslatedAttribute::computeOffset(const gl::Context *context, + GLint startVertex, + unsigned int *offsetOut) const +{ + if (!usesFirstVertexOffset) + { + *offsetOut = baseOffset; + return angle::Result::Continue; + } + + CheckedNumeric<unsigned int> offset(baseOffset); + CheckedNumeric<unsigned int> checkedStride(stride); + + offset += checkedStride * static_cast<unsigned int>(startVertex); + ANGLE_CHECK_GL_MATH(GetImplAs<ContextD3D>(context), offset.IsValid()); + *offsetOut = offset.ValueOrDie(); + return angle::Result::Continue; +} + +// Warning: you should ensure binding really matches attrib.bindingIndex before using this function. +VertexStorageType ClassifyAttributeStorage(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding) +{ + // If attribute is disabled, we use the current value. + if (!attrib.enabled) + { + return VertexStorageType::CURRENT_VALUE; + } + + // If specified with immediate data, we must use dynamic storage. + gl::Buffer *buffer = binding.getBuffer().get(); + if (!buffer) + { + return VertexStorageType::DYNAMIC; + } + + // Check if the buffer supports direct storage. + if (DirectStoragePossible(context, attrib, binding)) + { + return VertexStorageType::DIRECT; + } + + // Otherwise the storage is static or dynamic. + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + ASSERT(bufferD3D); + switch (bufferD3D->getUsage()) + { + case D3DBufferUsage::DYNAMIC: + return VertexStorageType::DYNAMIC; + case D3DBufferUsage::STATIC: + return VertexStorageType::STATIC; + default: + UNREACHABLE(); + return VertexStorageType::UNKNOWN; + } +} + +VertexDataManager::CurrentValueState::CurrentValueState(BufferFactoryD3D *factory) + : buffer(new StreamingVertexBufferInterface(factory)), offset(0) +{ + data.Values.FloatValues[0] = std::numeric_limits<float>::quiet_NaN(); + data.Values.FloatValues[1] = std::numeric_limits<float>::quiet_NaN(); + data.Values.FloatValues[2] = std::numeric_limits<float>::quiet_NaN(); + data.Values.FloatValues[3] = std::numeric_limits<float>::quiet_NaN(); + data.Type = gl::VertexAttribType::Float; +} + +VertexDataManager::CurrentValueState::CurrentValueState(CurrentValueState &&other) +{ + std::swap(buffer, other.buffer); + std::swap(data, other.data); + std::swap(offset, other.offset); +} + +VertexDataManager::CurrentValueState::~CurrentValueState() {} + +VertexDataManager::VertexDataManager(BufferFactoryD3D *factory) + : mFactory(factory), mStreamingBuffer(factory) +{ + mCurrentValueCache.reserve(gl::MAX_VERTEX_ATTRIBS); + for (int currentValueIndex = 0; currentValueIndex < gl::MAX_VERTEX_ATTRIBS; ++currentValueIndex) + { + mCurrentValueCache.emplace_back(factory); + } +} + +VertexDataManager::~VertexDataManager() {} + +angle::Result VertexDataManager::initialize(const gl::Context *context) +{ + return mStreamingBuffer.initialize(context, INITIAL_STREAM_BUFFER_SIZE); +} + +void VertexDataManager::deinitialize() +{ + mStreamingBuffer.reset(); + mCurrentValueCache.clear(); +} + +angle::Result VertexDataManager::prepareVertexData( + const gl::Context *context, + GLint start, + GLsizei count, + std::vector<TranslatedAttribute> *translatedAttribs, + GLsizei instances) +{ + const gl::State &state = context->getState(); + const gl::ProgramExecutable *executable = state.getProgramExecutable(); + const gl::VertexArray *vertexArray = state.getVertexArray(); + const auto &vertexAttributes = vertexArray->getVertexAttributes(); + const auto &vertexBindings = vertexArray->getVertexBindings(); + + mDynamicAttribsMaskCache.reset(); + + translatedAttribs->clear(); + + for (size_t attribIndex = 0; attribIndex < vertexAttributes.size(); ++attribIndex) + { + // Skip attrib locations the program doesn't use. + if (!executable->isAttribLocationActive(attribIndex)) + continue; + + const auto &attrib = vertexAttributes[attribIndex]; + const auto &binding = vertexBindings[attrib.bindingIndex]; + + // Resize automatically puts in empty attribs + translatedAttribs->resize(attribIndex + 1); + + TranslatedAttribute *translated = &(*translatedAttribs)[attribIndex]; + auto currentValueData = state.getVertexAttribCurrentValue(attribIndex); + + // Record the attribute now + translated->active = true; + translated->attribute = &attrib; + translated->binding = &binding; + translated->currentValueType = currentValueData.Type; + translated->divisor = binding.getDivisor(); + + switch (ClassifyAttributeStorage(context, attrib, binding)) + { + case VertexStorageType::STATIC: + { + // Store static attribute. + ANGLE_TRY(StoreStaticAttrib(context, translated)); + break; + } + case VertexStorageType::DYNAMIC: + // Dynamic attributes must be handled together. + mDynamicAttribsMaskCache.set(attribIndex); + break; + case VertexStorageType::DIRECT: + // Update translated data for direct attributes. + StoreDirectAttrib(context, translated); + break; + case VertexStorageType::CURRENT_VALUE: + { + ANGLE_TRY(storeCurrentValue(context, currentValueData, translated, attribIndex)); + break; + } + default: + UNREACHABLE(); + break; + } + } + + if (mDynamicAttribsMaskCache.none()) + { + return angle::Result::Continue; + } + + // prepareVertexData is only called by Renderer9 which don't support baseInstance + ANGLE_TRY(storeDynamicAttribs(context, translatedAttribs, mDynamicAttribsMaskCache, start, + count, instances, 0u)); + + PromoteDynamicAttribs(context, *translatedAttribs, mDynamicAttribsMaskCache, count); + + return angle::Result::Continue; +} + +// static +void VertexDataManager::StoreDirectAttrib(const gl::Context *context, + TranslatedAttribute *directAttrib) +{ + ASSERT(directAttrib->attribute && directAttrib->binding); + const auto &attrib = *directAttrib->attribute; + const auto &binding = *directAttrib->binding; + + gl::Buffer *buffer = binding.getBuffer().get(); + ASSERT(buffer); + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + + ASSERT(DirectStoragePossible(context, attrib, binding)); + directAttrib->vertexBuffer.set(nullptr); + directAttrib->storage = bufferD3D; + directAttrib->serial = bufferD3D->getSerial(); + directAttrib->stride = static_cast<unsigned int>(ComputeVertexAttributeStride(attrib, binding)); + directAttrib->baseOffset = + static_cast<unsigned int>(ComputeVertexAttributeOffset(attrib, binding)); + + // Instanced vertices do not apply the 'start' offset + directAttrib->usesFirstVertexOffset = (binding.getDivisor() == 0); +} + +// static +angle::Result VertexDataManager::StoreStaticAttrib(const gl::Context *context, + TranslatedAttribute *translated) +{ + ASSERT(translated->attribute && translated->binding); + const auto &attrib = *translated->attribute; + const auto &binding = *translated->binding; + + gl::Buffer *buffer = binding.getBuffer().get(); + ASSERT(buffer && attrib.enabled && !DirectStoragePossible(context, attrib, binding)); + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + + // Compute source data pointer + const uint8_t *sourceData = nullptr; + const int offset = static_cast<int>(ComputeVertexAttributeOffset(attrib, binding)); + + ANGLE_TRY(bufferD3D->getData(context, &sourceData)); + + if (sourceData) + { + sourceData += offset; + } + + unsigned int streamOffset = 0; + + translated->storage = nullptr; + ANGLE_TRY(bufferD3D->getFactory()->getVertexSpaceRequired(context, attrib, binding, 1, 0, 0, + &translated->stride)); + + auto *staticBuffer = bufferD3D->getStaticVertexBuffer(attrib, binding); + ASSERT(staticBuffer); + + if (staticBuffer->empty()) + { + // Convert the entire buffer + int totalCount = + ElementsInBuffer(attrib, binding, static_cast<unsigned int>(bufferD3D->getSize())); + int startIndex = offset / static_cast<int>(ComputeVertexAttributeStride(attrib, binding)); + + if (totalCount > 0) + { + ANGLE_TRY(staticBuffer->storeStaticAttribute(context, attrib, binding, -startIndex, + totalCount, 0, sourceData)); + } + } + + unsigned int firstElementOffset = + (static_cast<unsigned int>(offset) / + static_cast<unsigned int>(ComputeVertexAttributeStride(attrib, binding))) * + translated->stride; + + VertexBuffer *vertexBuffer = staticBuffer->getVertexBuffer(); + + CheckedNumeric<unsigned int> checkedOffset(streamOffset); + checkedOffset += firstElementOffset; + + ANGLE_CHECK_GL_MATH(GetImplAs<ContextD3D>(context), checkedOffset.IsValid()); + + translated->vertexBuffer.set(vertexBuffer); + translated->serial = vertexBuffer->getSerial(); + translated->baseOffset = streamOffset + firstElementOffset; + + // Instanced vertices do not apply the 'start' offset + translated->usesFirstVertexOffset = (binding.getDivisor() == 0); + + return angle::Result::Continue; +} + +angle::Result VertexDataManager::storeDynamicAttribs( + const gl::Context *context, + std::vector<TranslatedAttribute> *translatedAttribs, + const gl::AttributesMask &dynamicAttribsMask, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance) +{ + // Instantiating this class will ensure the streaming buffer is never left mapped. + class StreamingBufferUnmapper final : NonCopyable + { + public: + StreamingBufferUnmapper(StreamingVertexBufferInterface *streamingBuffer) + : mStreamingBuffer(streamingBuffer) + { + ASSERT(mStreamingBuffer); + } + ~StreamingBufferUnmapper() { mStreamingBuffer->getVertexBuffer()->hintUnmapResource(); } + + private: + StreamingVertexBufferInterface *mStreamingBuffer; + }; + + // Will trigger unmapping on return. + StreamingBufferUnmapper localUnmapper(&mStreamingBuffer); + + // Reserve the required space for the dynamic buffers. + for (auto attribIndex : dynamicAttribsMask) + { + const auto &dynamicAttrib = (*translatedAttribs)[attribIndex]; + ANGLE_TRY( + reserveSpaceForAttrib(context, dynamicAttrib, start, count, instances, baseInstance)); + } + + // Store dynamic attributes + for (auto attribIndex : dynamicAttribsMask) + { + auto *dynamicAttrib = &(*translatedAttribs)[attribIndex]; + ANGLE_TRY( + storeDynamicAttrib(context, dynamicAttrib, start, count, instances, baseInstance)); + } + + return angle::Result::Continue; +} + +void VertexDataManager::PromoteDynamicAttribs( + const gl::Context *context, + const std::vector<TranslatedAttribute> &translatedAttribs, + const gl::AttributesMask &dynamicAttribsMask, + size_t count) +{ + for (auto attribIndex : dynamicAttribsMask) + { + const auto &dynamicAttrib = translatedAttribs[attribIndex]; + ASSERT(dynamicAttrib.attribute && dynamicAttrib.binding); + const auto &binding = *dynamicAttrib.binding; + + gl::Buffer *buffer = binding.getBuffer().get(); + if (buffer) + { + // Note: this multiplication can overflow. It should not be a security problem. + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + size_t typeSize = ComputeVertexAttributeTypeSize(*dynamicAttrib.attribute); + bufferD3D->promoteStaticUsage(context, count * typeSize); + } + } +} + +angle::Result VertexDataManager::reserveSpaceForAttrib(const gl::Context *context, + const TranslatedAttribute &translatedAttrib, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance) +{ + ASSERT(translatedAttrib.attribute && translatedAttrib.binding); + const auto &attrib = *translatedAttrib.attribute; + const auto &binding = *translatedAttrib.binding; + + ASSERT(!DirectStoragePossible(context, attrib, binding)); + + gl::Buffer *buffer = binding.getBuffer().get(); + BufferD3D *bufferD3D = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr; + ASSERT(!bufferD3D || bufferD3D->getStaticVertexBuffer(attrib, binding) == nullptr); + + size_t totalCount = gl::ComputeVertexBindingElementCount(binding.getDivisor(), count, + static_cast<size_t>(instances)); + // TODO(jiajia.qin@intel.com): force the index buffer to clamp any out of range indices instead + // of invalid operation here. + if (bufferD3D) + { + // Vertices do not apply the 'start' offset when the divisor is non-zero even when doing + // a non-instanced draw call + GLint firstVertexIndex = binding.getDivisor() > 0 + ? UnsignedCeilDivide(baseInstance, binding.getDivisor()) + : start; + int64_t maxVertexCount = + static_cast<int64_t>(firstVertexIndex) + static_cast<int64_t>(totalCount); + + int64_t maxByte = GetMaxAttributeByteOffsetForDraw(attrib, binding, maxVertexCount); + + ASSERT(bufferD3D->getSize() <= static_cast<size_t>(std::numeric_limits<int64_t>::max())); + ANGLE_CHECK(GetImplAs<ContextD3D>(context), + maxByte <= static_cast<int64_t>(bufferD3D->getSize()), + "Vertex buffer is not big enough for the draw call.", GL_INVALID_OPERATION); + } + return mStreamingBuffer.reserveVertexSpace(context, attrib, binding, totalCount, instances, + baseInstance); +} + +angle::Result VertexDataManager::storeDynamicAttrib(const gl::Context *context, + TranslatedAttribute *translated, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance) +{ + ASSERT(translated->attribute && translated->binding); + const auto &attrib = *translated->attribute; + const auto &binding = *translated->binding; + + gl::Buffer *buffer = binding.getBuffer().get(); + ASSERT(buffer || attrib.pointer); + ASSERT(attrib.enabled); + + BufferD3D *storage = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr; + + // Instanced vertices do not apply the 'start' offset + GLint firstVertexIndex = + (binding.getDivisor() > 0 ? UnsignedCeilDivide(baseInstance, binding.getDivisor()) : start); + + // Compute source data pointer + const uint8_t *sourceData = nullptr; + + if (buffer) + { + ANGLE_TRY(storage->getData(context, &sourceData)); + sourceData += static_cast<int>(ComputeVertexAttributeOffset(attrib, binding)); + } + else + { + // Attributes using client memory ignore the VERTEX_ATTRIB_BINDING state. + // https://www.opengl.org/registry/specs/ARB/vertex_attrib_binding.txt + sourceData = static_cast<const uint8_t *>(attrib.pointer); + } + + unsigned int streamOffset = 0; + + translated->storage = nullptr; + ANGLE_TRY( + mFactory->getVertexSpaceRequired(context, attrib, binding, 1, 0, 0, &translated->stride)); + + size_t totalCount = gl::ComputeVertexBindingElementCount(binding.getDivisor(), count, + static_cast<size_t>(instances)); + + ANGLE_TRY(mStreamingBuffer.storeDynamicAttribute( + context, attrib, binding, translated->currentValueType, firstVertexIndex, + static_cast<GLsizei>(totalCount), instances, baseInstance, &streamOffset, sourceData)); + + VertexBuffer *vertexBuffer = mStreamingBuffer.getVertexBuffer(); + + translated->vertexBuffer.set(vertexBuffer); + translated->serial = vertexBuffer->getSerial(); + translated->baseOffset = streamOffset; + translated->usesFirstVertexOffset = false; + + return angle::Result::Continue; +} + +angle::Result VertexDataManager::storeCurrentValue( + const gl::Context *context, + const gl::VertexAttribCurrentValueData ¤tValue, + TranslatedAttribute *translated, + size_t attribIndex) +{ + CurrentValueState *cachedState = &mCurrentValueCache[attribIndex]; + StreamingVertexBufferInterface &buffer = *cachedState->buffer; + + if (buffer.getBufferSize() == 0) + { + ANGLE_TRY(buffer.initialize(context, CONSTANT_VERTEX_BUFFER_SIZE)); + } + + if (cachedState->data != currentValue) + { + ASSERT(translated->attribute && translated->binding); + const auto &attrib = *translated->attribute; + const auto &binding = *translated->binding; + + ANGLE_TRY(buffer.reserveVertexSpace(context, attrib, binding, 1, 0, 0)); + + const uint8_t *sourceData = + reinterpret_cast<const uint8_t *>(currentValue.Values.FloatValues); + unsigned int streamOffset; + ANGLE_TRY(buffer.storeDynamicAttribute(context, attrib, binding, currentValue.Type, 0, 1, 0, + 0, &streamOffset, sourceData)); + + buffer.getVertexBuffer()->hintUnmapResource(); + + cachedState->data = currentValue; + cachedState->offset = streamOffset; + } + + translated->vertexBuffer.set(buffer.getVertexBuffer()); + + translated->storage = nullptr; + translated->serial = buffer.getSerial(); + translated->divisor = 0; + translated->stride = 0; + translated->baseOffset = static_cast<unsigned int>(cachedState->offset); + translated->usesFirstVertexOffset = false; + + return angle::Result::Continue; +} + +// VertexBufferBinding implementation +VertexBufferBinding::VertexBufferBinding() : mBoundVertexBuffer(nullptr) {} + +VertexBufferBinding::VertexBufferBinding(const VertexBufferBinding &other) + : mBoundVertexBuffer(other.mBoundVertexBuffer) +{ + if (mBoundVertexBuffer) + { + mBoundVertexBuffer->addRef(); + } +} + +VertexBufferBinding::~VertexBufferBinding() +{ + if (mBoundVertexBuffer) + { + mBoundVertexBuffer->release(); + } +} + +VertexBufferBinding &VertexBufferBinding::operator=(const VertexBufferBinding &other) +{ + mBoundVertexBuffer = other.mBoundVertexBuffer; + if (mBoundVertexBuffer) + { + mBoundVertexBuffer->addRef(); + } + return *this; +} + +void VertexBufferBinding::set(VertexBuffer *vertexBuffer) +{ + if (mBoundVertexBuffer == vertexBuffer) + return; + + if (mBoundVertexBuffer) + { + mBoundVertexBuffer->release(); + } + if (vertexBuffer) + { + vertexBuffer->addRef(); + } + + mBoundVertexBuffer = vertexBuffer; +} + +VertexBuffer *VertexBufferBinding::get() const +{ + return mBoundVertexBuffer; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.h new file mode 100644 index 0000000000..50400db027 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/VertexDataManager.h @@ -0,0 +1,163 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexDataManager.h: Defines the VertexDataManager, a class that +// runs the Buffer translation process. + +#ifndef LIBANGLE_RENDERER_D3D_VERTEXDATAMANAGER_H_ +#define LIBANGLE_RENDERER_D3D_VERTEXDATAMANAGER_H_ + +#include "common/angleutils.h" +#include "libANGLE/Constants.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/VertexBuffer.h" + +namespace gl +{ +class State; +struct VertexAttribute; +class VertexBinding; +struct VertexAttribCurrentValueData; +} // namespace gl + +namespace rx +{ +class BufferD3D; +class BufferFactoryD3D; +class StreamingVertexBufferInterface; +class VertexBuffer; + +class VertexBufferBinding final +{ + public: + VertexBufferBinding(); + VertexBufferBinding(const VertexBufferBinding &other); + ~VertexBufferBinding(); + + void set(VertexBuffer *vertexBuffer); + VertexBuffer *get() const; + VertexBufferBinding &operator=(const VertexBufferBinding &other); + + private: + VertexBuffer *mBoundVertexBuffer; +}; + +struct TranslatedAttribute +{ + TranslatedAttribute(); + TranslatedAttribute(const TranslatedAttribute &other); + + // Computes the correct offset from baseOffset, usesFirstVertexOffset, stride and startVertex. + // Can throw an error on integer overflow. + angle::Result computeOffset(const gl::Context *context, + GLint startVertex, + unsigned int *offsetOut) const; + + bool active; + + const gl::VertexAttribute *attribute; + const gl::VertexBinding *binding; + gl::VertexAttribType currentValueType; + unsigned int baseOffset; + bool usesFirstVertexOffset; + unsigned int stride; // 0 means not to advance the read pointer at all + + VertexBufferBinding vertexBuffer; + BufferD3D *storage; + unsigned int serial; + unsigned int divisor; +}; + +enum class VertexStorageType +{ + UNKNOWN, + STATIC, // Translate the vertex data once and re-use it. + DYNAMIC, // Translate the data every frame into a ring buffer. + DIRECT, // Bind a D3D buffer directly without any translation. + CURRENT_VALUE, // Use a single value for the attribute. +}; + +// Given a vertex attribute, return the type of storage it will use. +VertexStorageType ClassifyAttributeStorage(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding); + +class VertexDataManager : angle::NonCopyable +{ + public: + VertexDataManager(BufferFactoryD3D *factory); + virtual ~VertexDataManager(); + + angle::Result initialize(const gl::Context *context); + void deinitialize(); + + angle::Result prepareVertexData(const gl::Context *context, + GLint start, + GLsizei count, + std::vector<TranslatedAttribute> *translatedAttribs, + GLsizei instances); + + static void StoreDirectAttrib(const gl::Context *context, TranslatedAttribute *directAttrib); + + static angle::Result StoreStaticAttrib(const gl::Context *context, + TranslatedAttribute *translated); + + angle::Result storeDynamicAttribs(const gl::Context *context, + std::vector<TranslatedAttribute> *translatedAttribs, + const gl::AttributesMask &dynamicAttribsMask, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance); + + // Promote static usage of dynamic buffers. + static void PromoteDynamicAttribs(const gl::Context *context, + const std::vector<TranslatedAttribute> &translatedAttribs, + const gl::AttributesMask &dynamicAttribsMask, + size_t count); + + angle::Result storeCurrentValue(const gl::Context *context, + const gl::VertexAttribCurrentValueData ¤tValue, + TranslatedAttribute *translated, + size_t attribIndex); + + private: + struct CurrentValueState final : angle::NonCopyable + { + CurrentValueState(BufferFactoryD3D *factory); + CurrentValueState(CurrentValueState &&other); + ~CurrentValueState(); + + std::unique_ptr<StreamingVertexBufferInterface> buffer; + gl::VertexAttribCurrentValueData data; + size_t offset; + }; + + angle::Result reserveSpaceForAttrib(const gl::Context *context, + const TranslatedAttribute &translatedAttrib, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance); + + angle::Result storeDynamicAttrib(const gl::Context *context, + TranslatedAttribute *translated, + GLint start, + size_t count, + GLsizei instances, + GLuint baseInstance); + + BufferFactoryD3D *const mFactory; + + StreamingVertexBufferInterface mStreamingBuffer; + std::vector<CurrentValueState> mCurrentValueCache; + gl::AttributesMask mDynamicAttribsMaskCache; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_VERTEXDATAMANAGER_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp new file mode 100644 index 0000000000..b78ecc5dee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp @@ -0,0 +1,1943 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Blit11.cpp: Texture copy utility class. + +#include "libANGLE/renderer/d3d/d3d11/Blit11.h" + +#include <float.h> + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "libANGLE/trace.h" + +namespace rx +{ + +namespace +{ + +// Include inline shaders in the anonymous namespace to make sure no symbols are exported +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h" + +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11gs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11vs.h" + +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h" + +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2darrayps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef3dps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2darrayps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei3dps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui3dps.h" + +void StretchedBlitNearest_RowByRow(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + size_t pixelSize, + const uint8_t *sourceData, + uint8_t *destData) +{ + int srcHeightSubOne = (sourceArea.height - 1); + size_t copySize = pixelSize * clippedDestArea.width; + size_t srcOffset = sourceArea.x * pixelSize; + size_t destOffset = clippedDestArea.x * pixelSize; + + for (int y = clippedDestArea.y; y < clippedDestArea.y + clippedDestArea.height; y++) + { + // TODO: Fix divide by zero when height == 1. http://anglebug.com/6099 + float yPerc = static_cast<float>(y - destArea.y) / (destArea.height - 1); + + // Interpolate using the original source rectangle to determine which row to sample from + // while clamping to the edges + unsigned int readRow = static_cast<unsigned int>( + gl::clamp(sourceArea.y + floor(yPerc * srcHeightSubOne + 0.5f), 0, srcHeightSubOne)); + unsigned int writeRow = y; + + const uint8_t *sourceRow = sourceData + readRow * sourceRowPitch + srcOffset; + uint8_t *destRow = destData + writeRow * destRowPitch + destOffset; + memcpy(destRow, sourceRow, copySize); + } +} + +void StretchedBlitNearest_PixelByPixel(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + auto xMax = clippedDestArea.x + clippedDestArea.width; + auto yMax = clippedDestArea.y + clippedDestArea.height; + + for (int writeRow = clippedDestArea.y; writeRow < yMax; writeRow++) + { + // Interpolate using the original source rectangle to determine which row to sample from + // while clamping to the edges + float yPerc = static_cast<float>(writeRow - destArea.y) / (destArea.height - 1); + float yRounded = floor(yPerc * (sourceArea.height - 1) + 0.5f); + unsigned int readRow = + static_cast<unsigned int>(gl::clamp(sourceArea.y + yRounded, 0, sourceSize.height - 1)); + + for (int writeColumn = clippedDestArea.x; writeColumn < xMax; writeColumn++) + { + // Interpolate the original source rectangle to determine which column to sample + // from while clamping to the edges + float xPerc = static_cast<float>(writeColumn - destArea.x) / (destArea.width - 1); + float xRounded = floor(xPerc * (sourceArea.width - 1) + 0.5f); + unsigned int readColumn = static_cast<unsigned int>( + gl::clamp(sourceArea.x + xRounded, 0, sourceSize.width - 1)); + + const uint8_t *sourcePixel = + sourceData + readRow * sourceRowPitch + readColumn * srcPixelStride + readOffset; + + uint8_t *destPixel = + destData + writeRow * destRowPitch + writeColumn * destPixelStride + writeOffset; + + memcpy(destPixel, sourcePixel, copySize); + } + } +} + +void StretchedBlitNearest(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clipRect, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + gl::Rectangle clippedDestArea(destArea.x, destArea.y, destArea.width, destArea.height); + if (!gl::ClipRectangle(clippedDestArea, clipRect, &clippedDestArea)) + { + return; + } + + // Determine if entire rows can be copied at once instead of each individual pixel. There + // must be no out of bounds lookups, whole rows copies, and no scale. + if (sourceArea.width == clippedDestArea.width && sourceArea.x >= 0 && + sourceArea.x + sourceArea.width <= sourceSize.width && copySize == srcPixelStride && + copySize == destPixelStride) + { + StretchedBlitNearest_RowByRow(sourceArea, destArea, clippedDestArea, sourceSize, + sourceRowPitch, destRowPitch, srcPixelStride, sourceData, + destData); + } + else + { + StretchedBlitNearest_PixelByPixel(sourceArea, destArea, clippedDestArea, sourceSize, + sourceRowPitch, destRowPitch, readOffset, writeOffset, + copySize, srcPixelStride, destPixelStride, sourceData, + destData); + } +} + +using DepthStencilLoader = void(const float *, uint8_t *); + +void LoadDepth16(const float *source, uint8_t *dest) +{ + uint32_t convertedDepth = gl::floatToNormalized<16, uint32_t>(source[0]); + memcpy(dest, &convertedDepth, 2u); +} + +void LoadDepth24(const float *source, uint8_t *dest) +{ + uint32_t convertedDepth = gl::floatToNormalized<24, uint32_t>(source[0]); + memcpy(dest, &convertedDepth, 3u); +} + +void LoadStencilHelper(const float *source, uint8_t *dest) +{ + uint32_t convertedStencil = gl::getShiftedData<8, 0>(static_cast<uint32_t>(source[1])); + memcpy(dest, &convertedStencil, 1u); +} + +void LoadStencil8(const float *source, uint8_t *dest) +{ + // STENCIL_INDEX8 is implemented with D24S8, with the depth bits unused. Writes zero for safety. + float zero = 0.0f; + LoadDepth24(&zero, &dest[0]); + LoadStencilHelper(source, &dest[3]); +} + +void LoadDepth24Stencil8(const float *source, uint8_t *dest) +{ + LoadDepth24(source, &dest[0]); + LoadStencilHelper(source, &dest[3]); +} + +void LoadDepth32F(const float *source, uint8_t *dest) +{ + memcpy(dest, source, sizeof(float)); +} + +void LoadDepth32FStencil8(const float *source, uint8_t *dest) +{ + LoadDepth32F(source, &dest[0]); + LoadStencilHelper(source, &dest[4]); +} + +template <DepthStencilLoader loader> +void CopyDepthStencil(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const float *sourcePixel = reinterpret_cast<const float *>(sourceData + offset); + + uint8_t *destPixel = destData + row * destRowPitch + column * destPixelStride; + + loader(sourcePixel, destPixel); + } + } +} + +void Depth32FStencil8ToDepth32F(const float *source, float *dest) +{ + *dest = *source; +} + +void Depth24Stencil8ToDepth32F(const uint32_t *source, float *dest) +{ + uint32_t normDepth = source[0] & 0x00FFFFFF; + float floatDepth = gl::normalizedToFloat<24>(normDepth); + *dest = floatDepth; +} + +void BlitD24S8ToD32F(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const uint32_t *sourcePixel = reinterpret_cast<const uint32_t *>(sourceData + offset); + + float *destPixel = + reinterpret_cast<float *>(destData + row * destRowPitch + column * destPixelStride); + + Depth24Stencil8ToDepth32F(sourcePixel, destPixel); + } + } +} + +void BlitD32FS8ToD32F(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const float *sourcePixel = reinterpret_cast<const float *>(sourceData + offset); + float *destPixel = + reinterpret_cast<float *>(destData + row * destRowPitch + column * destPixelStride); + + Depth32FStencil8ToDepth32F(sourcePixel, destPixel); + } + } +} + +Blit11::BlitConvertFunction *GetCopyDepthStencilFunction(GLenum internalFormat) +{ + switch (internalFormat) + { + case GL_DEPTH_COMPONENT16: + return &CopyDepthStencil<LoadDepth16>; + case GL_DEPTH_COMPONENT24: + return &CopyDepthStencil<LoadDepth24>; + case GL_DEPTH_COMPONENT32F: + return &CopyDepthStencil<LoadDepth32F>; + case GL_STENCIL_INDEX8: + return &CopyDepthStencil<LoadStencil8>; + case GL_DEPTH24_STENCIL8: + return &CopyDepthStencil<LoadDepth24Stencil8>; + case GL_DEPTH32F_STENCIL8: + return &CopyDepthStencil<LoadDepth32FStencil8>; + default: + UNREACHABLE(); + return nullptr; + } +} + +inline void GenerateVertexCoords(const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const gl::Box &destArea, + const gl::Extents &destSize, + float *x1, + float *y1, + float *x2, + float *y2, + float *u1, + float *v1, + float *u2, + float *v2) +{ + *x1 = (destArea.x / float(destSize.width)) * 2.0f - 1.0f; + *y1 = ((destSize.height - destArea.y - destArea.height) / float(destSize.height)) * 2.0f - 1.0f; + *x2 = ((destArea.x + destArea.width) / float(destSize.width)) * 2.0f - 1.0f; + *y2 = ((destSize.height - destArea.y) / float(destSize.height)) * 2.0f - 1.0f; + + *u1 = sourceArea.x / float(sourceSize.width); + *v1 = sourceArea.y / float(sourceSize.height); + *u2 = (sourceArea.x + sourceArea.width) / float(sourceSize.width); + *v2 = (sourceArea.y + sourceArea.height) / float(sourceSize.height); +} + +void Write2DVertices(const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const gl::Box &destArea, + const gl::Extents &destSize, + void *outVertices, + unsigned int *outStride, + unsigned int *outVertexCount, + D3D11_PRIMITIVE_TOPOLOGY *outTopology) +{ + float x1, y1, x2, y2, u1, v1, u2, v2; + GenerateVertexCoords(sourceArea, sourceSize, destArea, destSize, &x1, &y1, &x2, &y2, &u1, &v1, + &u2, &v2); + + d3d11::PositionTexCoordVertex *vertices = + static_cast<d3d11::PositionTexCoordVertex *>(outVertices); + + d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v2); + d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v1); + d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v2); + d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v1); + + *outStride = sizeof(d3d11::PositionTexCoordVertex); + *outVertexCount = 4; + *outTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; +} + +void Write3DVertices(const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const gl::Box &destArea, + const gl::Extents &destSize, + void *outVertices, + unsigned int *outStride, + unsigned int *outVertexCount, + D3D11_PRIMITIVE_TOPOLOGY *outTopology) +{ + ASSERT(sourceSize.depth > 0 && destSize.depth > 0); + + float x1, y1, x2, y2, u1, v1, u2, v2; + GenerateVertexCoords(sourceArea, sourceSize, destArea, destSize, &x1, &y1, &x2, &y2, &u1, &v1, + &u2, &v2); + + d3d11::PositionLayerTexCoord3DVertex *vertices = + static_cast<d3d11::PositionLayerTexCoord3DVertex *>(outVertices); + + for (int i = 0; i < destSize.depth; i++) + { + float readDepth = (float)i / std::max(destSize.depth - 1, 1); + + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 0], x1, y1, i, u1, v2, readDepth); + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 1], x1, y2, i, u1, v1, readDepth); + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 2], x2, y1, i, u2, v2, readDepth); + + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 3], x1, y2, i, u1, v1, readDepth); + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 4], x2, y2, i, u2, v1, readDepth); + d3d11::SetPositionLayerTexCoord3DVertex(&vertices[i * 6 + 5], x2, y1, i, u2, v2, readDepth); + } + + *outStride = sizeof(d3d11::PositionLayerTexCoord3DVertex); + *outVertexCount = destSize.depth * 6; + *outTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; +} + +unsigned int GetSwizzleIndex(GLenum swizzle) +{ + unsigned int colorIndex = 0; + + switch (swizzle) + { + case GL_RED: + colorIndex = 0; + break; + case GL_GREEN: + colorIndex = 1; + break; + case GL_BLUE: + colorIndex = 2; + break; + case GL_ALPHA: + colorIndex = 3; + break; + case GL_ZERO: + colorIndex = 4; + break; + case GL_ONE: + colorIndex = 5; + break; + default: + UNREACHABLE(); + break; + } + + return colorIndex; +} + +D3D11_BLEND_DESC GetAlphaMaskBlendStateDesc() +{ + D3D11_BLEND_DESC desc; + memset(&desc, 0, sizeof(desc)); + desc.RenderTarget[0].BlendEnable = TRUE; + desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; + desc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO; + desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; + desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO; + desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; + desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; + desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_RED | + D3D11_COLOR_WRITE_ENABLE_GREEN | + D3D11_COLOR_WRITE_ENABLE_BLUE; + return desc; +} + +D3D11_INPUT_ELEMENT_DESC quad2DLayout[] = { + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; + +D3D11_INPUT_ELEMENT_DESC quad3DLayout[] = { + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"LAYER", 0, DXGI_FORMAT_R32_UINT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}, +}; + +DXGI_FORMAT GetStencilSRVFormat(const d3d11::Format &formatSet) +{ + switch (formatSet.texFormat) + { + case DXGI_FORMAT_R32G8X24_TYPELESS: + return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; + case DXGI_FORMAT_R24G8_TYPELESS: + return DXGI_FORMAT_X24_TYPELESS_G8_UINT; + default: + UNREACHABLE(); + return DXGI_FORMAT_UNKNOWN; + } +} + +} // namespace + +#include "libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc" + +Blit11::Shader::Shader() = default; + +Blit11::Shader::Shader(Shader &&other) = default; + +Blit11::Shader::~Shader() = default; + +Blit11::Shader &Blit11::Shader::operator=(Blit11::Shader &&other) = default; + +Blit11::Blit11(Renderer11 *renderer) + : mRenderer(renderer), + mResourcesInitialized(false), + mVertexBuffer(), + mPointSampler(), + mLinearSampler(), + mScissorEnabledRasterizerState(), + mScissorDisabledRasterizerState(), + mDepthStencilState(), + mQuad2DIL(quad2DLayout, + ArraySize(quad2DLayout), + g_VS_Passthrough2D, + ArraySize(g_VS_Passthrough2D), + "Blit11 2D input layout"), + mQuad2DVS(g_VS_Passthrough2D, ArraySize(g_VS_Passthrough2D), "Blit11 2D vertex shader"), + mDepthPS(g_PS_PassthroughDepth2D, + ArraySize(g_PS_PassthroughDepth2D), + "Blit11 2D depth pixel shader"), + mQuad3DIL(quad3DLayout, + ArraySize(quad3DLayout), + g_VS_Passthrough3D, + ArraySize(g_VS_Passthrough3D), + "Blit11 3D input layout"), + mQuad3DVS(g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), "Blit11 3D vertex shader"), + mQuad3DGS(g_GS_Passthrough3D, ArraySize(g_GS_Passthrough3D), "Blit11 3D geometry shader"), + mAlphaMaskBlendState(GetAlphaMaskBlendStateDesc(), "Blit11 Alpha Mask Blend"), + mSwizzleCB(), + mResolveDepthStencilVS(g_VS_ResolveDepthStencil, + ArraySize(g_VS_ResolveDepthStencil), + "Blit11::mResolveDepthStencilVS"), + mResolveDepthPS(g_PS_ResolveDepth, ArraySize(g_PS_ResolveDepth), "Blit11::mResolveDepthPS"), + mResolveDepthStencilPS(g_PS_ResolveDepthStencil, + ArraySize(g_PS_ResolveDepthStencil), + "Blit11::mResolveDepthStencilPS"), + mResolveStencilPS(g_PS_ResolveStencil, + ArraySize(g_PS_ResolveStencil), + "Blit11::mResolveStencilPS"), + mStencilSRV(), + mResolvedDepthStencilRTView() +{} + +Blit11::~Blit11() {} + +angle::Result Blit11::initResources(const gl::Context *context) +{ + if (mResourcesInitialized) + { + return angle::Result::Continue; + } + + ANGLE_TRACE_EVENT0("gpu.angle", "Blit11::initResources"); + + D3D11_BUFFER_DESC vbDesc; + vbDesc.ByteWidth = + static_cast<unsigned int>(std::max(sizeof(d3d11::PositionLayerTexCoord3DVertex), + sizeof(d3d11::PositionTexCoordVertex)) * + 6 * mRenderer->getNativeCaps().max3DTextureSize); + vbDesc.Usage = D3D11_USAGE_DYNAMIC; + vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + vbDesc.MiscFlags = 0; + vbDesc.StructureByteStride = 0; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mRenderer->allocateResource(context11, vbDesc, &mVertexBuffer)); + mVertexBuffer.setInternalName("Blit11VertexBuffer"); + + D3D11_SAMPLER_DESC pointSamplerDesc; + pointSamplerDesc.Filter = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR; + pointSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + pointSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + pointSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + pointSamplerDesc.MipLODBias = 0.0f; + pointSamplerDesc.MaxAnisotropy = 0; + pointSamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + pointSamplerDesc.BorderColor[0] = 0.0f; + pointSamplerDesc.BorderColor[1] = 0.0f; + pointSamplerDesc.BorderColor[2] = 0.0f; + pointSamplerDesc.BorderColor[3] = 0.0f; + pointSamplerDesc.MinLOD = 0.0f; + pointSamplerDesc.MaxLOD = FLT_MAX; + + ANGLE_TRY(mRenderer->allocateResource(context11, pointSamplerDesc, &mPointSampler)); + mPointSampler.setInternalName("Blit11PointSampler"); + + D3D11_SAMPLER_DESC linearSamplerDesc; + linearSamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; + linearSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + linearSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + linearSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + linearSamplerDesc.MipLODBias = 0.0f; + linearSamplerDesc.MaxAnisotropy = 0; + linearSamplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + linearSamplerDesc.BorderColor[0] = 0.0f; + linearSamplerDesc.BorderColor[1] = 0.0f; + linearSamplerDesc.BorderColor[2] = 0.0f; + linearSamplerDesc.BorderColor[3] = 0.0f; + linearSamplerDesc.MinLOD = 0.0f; + linearSamplerDesc.MaxLOD = FLT_MAX; + + ANGLE_TRY(mRenderer->allocateResource(context11, linearSamplerDesc, &mLinearSampler)); + mLinearSampler.setInternalName("Blit11LinearSampler"); + + // Use a rasterizer state that will not cull so that inverted quads will not be culled + D3D11_RASTERIZER_DESC rasterDesc; + rasterDesc.FillMode = D3D11_FILL_SOLID; + rasterDesc.CullMode = D3D11_CULL_NONE; + rasterDesc.FrontCounterClockwise = FALSE; + rasterDesc.DepthBias = 0; + rasterDesc.SlopeScaledDepthBias = 0.0f; + rasterDesc.DepthBiasClamp = 0.0f; + rasterDesc.DepthClipEnable = TRUE; + rasterDesc.MultisampleEnable = FALSE; + rasterDesc.AntialiasedLineEnable = FALSE; + + rasterDesc.ScissorEnable = TRUE; + ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mScissorEnabledRasterizerState)); + mScissorEnabledRasterizerState.setInternalName("Blit11ScissoringRasterizerState"); + + rasterDesc.ScissorEnable = FALSE; + ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mScissorDisabledRasterizerState)); + mScissorDisabledRasterizerState.setInternalName("Blit11NoScissoringRasterizerState"); + + D3D11_DEPTH_STENCIL_DESC depthStencilDesc; + depthStencilDesc.DepthEnable = TRUE; + depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; + depthStencilDesc.DepthFunc = D3D11_COMPARISON_ALWAYS; + depthStencilDesc.StencilEnable = FALSE; + depthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; + depthStencilDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; + depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; + depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; + + ANGLE_TRY(mRenderer->allocateResource(context11, depthStencilDesc, &mDepthStencilState)); + mDepthStencilState.setInternalName("Blit11DepthStencilState"); + + D3D11_BUFFER_DESC swizzleBufferDesc; + swizzleBufferDesc.ByteWidth = sizeof(unsigned int) * 4; + swizzleBufferDesc.Usage = D3D11_USAGE_DYNAMIC; + swizzleBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + swizzleBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + swizzleBufferDesc.MiscFlags = 0; + swizzleBufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, swizzleBufferDesc, &mSwizzleCB)); + mSwizzleCB.setInternalName("Blit11SwizzleConstantBuffer"); + + mResourcesInitialized = true; + + return angle::Result::Continue; +} + +// static +Blit11::SwizzleShaderType Blit11::GetSwizzleShaderType(GLenum type, + D3D11_SRV_DIMENSION dimensionality) +{ + switch (dimensionality) + { + case D3D11_SRV_DIMENSION_TEXTURE2D: + switch (type) + { + case GL_FLOAT: + return SWIZZLESHADER_2D_FLOAT; + case GL_UNSIGNED_INT: + return SWIZZLESHADER_2D_UINT; + case GL_INT: + return SWIZZLESHADER_2D_INT; + default: + UNREACHABLE(); + return SWIZZLESHADER_INVALID; + } + case D3D11_SRV_DIMENSION_TEXTURECUBE: + switch (type) + { + case GL_FLOAT: + return SWIZZLESHADER_CUBE_FLOAT; + case GL_UNSIGNED_INT: + return SWIZZLESHADER_CUBE_UINT; + case GL_INT: + return SWIZZLESHADER_CUBE_INT; + default: + UNREACHABLE(); + return SWIZZLESHADER_INVALID; + } + case D3D11_SRV_DIMENSION_TEXTURE3D: + switch (type) + { + case GL_FLOAT: + return SWIZZLESHADER_3D_FLOAT; + case GL_UNSIGNED_INT: + return SWIZZLESHADER_3D_UINT; + case GL_INT: + return SWIZZLESHADER_3D_INT; + default: + UNREACHABLE(); + return SWIZZLESHADER_INVALID; + } + case D3D11_SRV_DIMENSION_TEXTURE2DARRAY: + switch (type) + { + case GL_FLOAT: + return SWIZZLESHADER_ARRAY_FLOAT; + case GL_UNSIGNED_INT: + return SWIZZLESHADER_ARRAY_UINT; + case GL_INT: + return SWIZZLESHADER_ARRAY_INT; + default: + UNREACHABLE(); + return SWIZZLESHADER_INVALID; + } + default: + UNREACHABLE(); + return SWIZZLESHADER_INVALID; + } +} + +angle::Result Blit11::getShaderSupport(const gl::Context *context, + const Shader &shader, + Blit11::ShaderSupport *supportOut) +{ + + Context11 *context11 = GetImplAs<Context11>(context); + + switch (shader.dimension) + { + case SHADER_2D: + { + ANGLE_TRY(mQuad2DIL.resolve(context11, mRenderer)); + ANGLE_TRY(mQuad2DVS.resolve(context11, mRenderer)); + supportOut->inputLayout = &mQuad2DIL.getObj(); + supportOut->vertexShader = &mQuad2DVS.getObj(); + supportOut->geometryShader = nullptr; + supportOut->vertexWriteFunction = Write2DVertices; + break; + } + case SHADER_3D: + case SHADER_2DARRAY: + { + ANGLE_TRY(mQuad3DIL.resolve(context11, mRenderer)); + ANGLE_TRY(mQuad3DVS.resolve(context11, mRenderer)); + ANGLE_TRY(mQuad3DGS.resolve(context11, mRenderer)); + supportOut->inputLayout = &mQuad3DIL.getObj(); + supportOut->vertexShader = &mQuad3DVS.getObj(); + supportOut->geometryShader = &mQuad3DGS.getObj(); + supportOut->vertexWriteFunction = Write3DVertices; + break; + } + default: + UNREACHABLE(); + } + + return angle::Result::Continue; +} + +angle::Result Blit11::swizzleTexture(const gl::Context *context, + const d3d11::SharedSRV &source, + const d3d11::RenderTargetView &dest, + const gl::Extents &size, + const gl::SwizzleState &swizzleTarget) +{ + ANGLE_TRY(initResources(context)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + D3D11_SHADER_RESOURCE_VIEW_DESC sourceSRVDesc; + source.get()->GetDesc(&sourceSRVDesc); + + GLenum componentType = d3d11::GetComponentType(sourceSRVDesc.Format); + if (componentType == GL_NONE) + { + // We're swizzling the depth component of a depth-stencil texture. + switch (sourceSRVDesc.Format) + { + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + componentType = GL_UNSIGNED_NORMALIZED; + break; + case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: + componentType = GL_FLOAT; + break; + default: + UNREACHABLE(); + break; + } + } + + GLenum shaderType = GL_NONE; + switch (componentType) + { + case GL_UNSIGNED_NORMALIZED: + case GL_SIGNED_NORMALIZED: + case GL_FLOAT: + shaderType = GL_FLOAT; + break; + case GL_INT: + shaderType = GL_INT; + break; + case GL_UNSIGNED_INT: + shaderType = GL_UNSIGNED_INT; + break; + default: + UNREACHABLE(); + break; + } + + const Shader *shader = nullptr; + ANGLE_TRY(getSwizzleShader(context, shaderType, sourceSRVDesc.ViewDimension, &shader)); + + // Set vertices + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + ShaderSupport support; + ANGLE_TRY(getShaderSupport(context, *shader, &support)); + + UINT stride = 0; + UINT drawCount = 0; + D3D11_PRIMITIVE_TOPOLOGY topology; + + gl::Box area(0, 0, 0, size.width, size.height, size.depth); + support.vertexWriteFunction(area, size, area, size, mappedResource.pData, &stride, &drawCount, + &topology); + + deviceContext->Unmap(mVertexBuffer.get(), 0); + + // Set constant buffer + ANGLE_TRY(mRenderer->mapResource(context, mSwizzleCB.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + unsigned int *swizzleIndices = static_cast<unsigned int *>(mappedResource.pData); + swizzleIndices[0] = GetSwizzleIndex(swizzleTarget.swizzleRed); + swizzleIndices[1] = GetSwizzleIndex(swizzleTarget.swizzleGreen); + swizzleIndices[2] = GetSwizzleIndex(swizzleTarget.swizzleBlue); + swizzleIndices[3] = GetSwizzleIndex(swizzleTarget.swizzleAlpha); + + deviceContext->Unmap(mSwizzleCB.get(), 0); + + StateManager11 *stateManager = mRenderer->getStateManager(); + + // Apply vertex buffer + stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0); + + // Apply constant buffer + stateManager->setPixelConstantBuffer(0, &mSwizzleCB); + + // Apply state + stateManager->setSimpleBlendState(nullptr); + stateManager->setDepthStencilState(nullptr, 0xFFFFFFFF); + stateManager->setRasterizerState(&mScissorDisabledRasterizerState); + + // Apply shaders + stateManager->setInputLayout(support.inputLayout); + stateManager->setPrimitiveTopology(topology); + + stateManager->setDrawShaders(support.vertexShader, support.geometryShader, + &shader->pixelShader); + + // Apply render target + stateManager->setRenderTarget(dest.get(), nullptr); + + // Set the viewport + stateManager->setSimpleViewport(size); + + // Apply textures and sampler + stateManager->setSimplePixelTextureAndSampler(source, mPointSampler); + + // Draw the quad + deviceContext->Draw(drawCount, 0); + + return angle::Result::Continue; +} + +angle::Result Blit11::copyTexture(const gl::Context *context, + const d3d11::SharedSRV &source, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + GLenum sourceFormat, + const d3d11::RenderTargetView &dest, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + GLenum destFormat, + GLenum destTypeForDownsampling, + GLenum filter, + bool maskOffAlpha, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + ANGLE_TRY(initResources(context)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // Determine if the source format is a signed integer format, the destFormat will already + // be GL_XXXX_INTEGER but it does not tell us if it is signed or unsigned. + D3D11_SHADER_RESOURCE_VIEW_DESC sourceSRVDesc; + source.get()->GetDesc(&sourceSRVDesc); + + GLenum componentType = d3d11::GetComponentType(sourceSRVDesc.Format); + + ASSERT(componentType != GL_NONE); + ASSERT(componentType != GL_SIGNED_NORMALIZED); + bool isSrcSigned = (componentType == GL_INT); + + D3D11_RENDER_TARGET_VIEW_DESC destRTVDesc; + dest.get()->GetDesc(&destRTVDesc); + + GLenum destComponentType = d3d11::GetComponentType(destRTVDesc.Format); + + ASSERT(componentType != GL_NONE); + bool isDestSigned = (destComponentType == GL_INT); + + ShaderDimension dimension = SHADER_INVALID; + + switch (sourceSRVDesc.ViewDimension) + { + case D3D11_SRV_DIMENSION_TEXTURE2D: + dimension = SHADER_2D; + break; + case D3D11_SRV_DIMENSION_TEXTURE3D: + dimension = SHADER_3D; + break; + case D3D11_SRV_DIMENSION_TEXTURE2DARRAY: + dimension = SHADER_2DARRAY; + break; + default: + UNREACHABLE(); + } + + const Shader *shader = nullptr; + + ANGLE_TRY(getBlitShader(context, destFormat, sourceFormat, isSrcSigned, isDestSigned, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha, destTypeForDownsampling, + dimension, &shader)); + + ShaderSupport support; + ANGLE_TRY(getShaderSupport(context, *shader, &support)); + + // Set vertices + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + UINT stride = 0; + UINT drawCount = 0; + D3D11_PRIMITIVE_TOPOLOGY topology; + + support.vertexWriteFunction(sourceArea, sourceSize, destArea, destSize, mappedResource.pData, + &stride, &drawCount, &topology); + + deviceContext->Unmap(mVertexBuffer.get(), 0); + + StateManager11 *stateManager = mRenderer->getStateManager(); + + // Apply vertex buffer + stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0); + + // Apply state + if (maskOffAlpha) + { + ANGLE_TRY(mAlphaMaskBlendState.resolve(GetImplAs<Context11>(context), mRenderer)); + stateManager->setSimpleBlendState(&mAlphaMaskBlendState.getObj()); + } + else + { + stateManager->setSimpleBlendState(nullptr); + } + stateManager->setDepthStencilState(nullptr, 0xFFFFFFFF); + + if (scissor) + { + stateManager->setSimpleScissorRect(*scissor); + stateManager->setRasterizerState(&mScissorEnabledRasterizerState); + } + else + { + stateManager->setRasterizerState(&mScissorDisabledRasterizerState); + } + + // Apply shaders + stateManager->setInputLayout(support.inputLayout); + stateManager->setPrimitiveTopology(topology); + + stateManager->setDrawShaders(support.vertexShader, support.geometryShader, + &shader->pixelShader); + + // Apply render target + stateManager->setRenderTarget(dest.get(), nullptr); + + // Set the viewport + stateManager->setSimpleViewport(destSize); + + // Apply texture and sampler + switch (filter) + { + case GL_NEAREST: + stateManager->setSimplePixelTextureAndSampler(source, mPointSampler); + break; + case GL_LINEAR: + stateManager->setSimplePixelTextureAndSampler(source, mLinearSampler); + break; + + default: + UNREACHABLE(); + ANGLE_TRY_HR(GetImplAs<Context11>(context), E_FAIL, + "Internal error, unknown blit filter mode."); + } + + // Draw the quad + deviceContext->Draw(drawCount, 0); + + return angle::Result::Continue; +} + +angle::Result Blit11::copyStencil(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor) +{ + return copyDepthStencilImpl(context, source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, true); +} + +angle::Result Blit11::copyDepth(const gl::Context *context, + const d3d11::SharedSRV &source, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const d3d11::DepthStencilView &dest, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor) +{ + ANGLE_TRY(initResources(context)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // Set vertices + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + UINT stride = 0; + UINT drawCount = 0; + D3D11_PRIMITIVE_TOPOLOGY topology; + + Write2DVertices(sourceArea, sourceSize, destArea, destSize, mappedResource.pData, &stride, + &drawCount, &topology); + + deviceContext->Unmap(mVertexBuffer.get(), 0); + + StateManager11 *stateManager = mRenderer->getStateManager(); + + // Apply vertex buffer + stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0); + + // Apply state + stateManager->setSimpleBlendState(nullptr); + stateManager->setDepthStencilState(&mDepthStencilState, 0xFFFFFFFF); + + if (scissor) + { + stateManager->setSimpleScissorRect(*scissor); + stateManager->setRasterizerState(&mScissorEnabledRasterizerState); + } + else + { + stateManager->setRasterizerState(&mScissorDisabledRasterizerState); + } + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mQuad2DIL.resolve(context11, mRenderer)); + ANGLE_TRY(mQuad2DVS.resolve(context11, mRenderer)); + ANGLE_TRY(mDepthPS.resolve(context11, mRenderer)); + + // Apply shaders + stateManager->setInputLayout(&mQuad2DIL.getObj()); + stateManager->setPrimitiveTopology(topology); + + stateManager->setDrawShaders(&mQuad2DVS.getObj(), nullptr, &mDepthPS.getObj()); + + // Apply render target + stateManager->setRenderTarget(nullptr, dest.get()); + + // Set the viewport + stateManager->setSimpleViewport(destSize); + + // Apply texture and sampler + stateManager->setSimplePixelTextureAndSampler(source, mPointSampler); + + // Draw the quad + deviceContext->Draw(drawCount, 0); + + return angle::Result::Continue; +} + +angle::Result Blit11::copyDepthStencil(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor) +{ + return copyDepthStencilImpl(context, source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, false); +} + +angle::Result Blit11::copyDepthStencilImpl(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + bool stencilOnly) +{ + auto srcDXGIFormat = source.getFormat(); + const auto &srcSizeInfo = d3d11::GetDXGIFormatSizeInfo(srcDXGIFormat); + unsigned int srcPixelSize = srcSizeInfo.pixelBytes; + unsigned int copyOffset = 0; + unsigned int copySize = srcPixelSize; + auto destDXGIFormat = dest.getFormat(); + const auto &destSizeInfo = d3d11::GetDXGIFormatSizeInfo(destDXGIFormat); + unsigned int destPixelSize = destSizeInfo.pixelBytes; + + ASSERT(srcDXGIFormat == destDXGIFormat || destDXGIFormat == DXGI_FORMAT_R32_TYPELESS); + + if (stencilOnly) + { + const auto &srcFormat = source.getFormatSet().format(); + + // Stencil channel should be right after the depth channel. Some views to depth/stencil + // resources have red channel for depth, in which case the depth channel bit width is in + // redBits. + ASSERT((srcFormat.redBits != 0) != (srcFormat.depthBits != 0)); + GLuint depthBits = srcFormat.redBits + srcFormat.depthBits; + // Known formats have either 24 or 32 bits of depth. + ASSERT(depthBits == 24 || depthBits == 32); + copyOffset = depthBits / 8; + + // Stencil is assumed to be 8-bit - currently this is true for all possible formats. + copySize = 1; + } + + if (srcDXGIFormat != destDXGIFormat) + { + if (srcDXGIFormat == DXGI_FORMAT_R24G8_TYPELESS) + { + ASSERT(sourceArea == destArea && sourceSize == destSize && scissor == nullptr); + return copyAndConvert(context, source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, copyOffset, + copyOffset, copySize, srcPixelSize, destPixelSize, + BlitD24S8ToD32F); + } + ASSERT(srcDXGIFormat == DXGI_FORMAT_R32G8X24_TYPELESS); + return copyAndConvert(context, source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, copyOffset, copyOffset, + copySize, srcPixelSize, destPixelSize, BlitD32FS8ToD32F); + } + + return copyAndConvert(context, source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, copyOffset, copyOffset, + copySize, srcPixelSize, destPixelSize, StretchedBlitNearest); +} + +angle::Result Blit11::copyAndConvertImpl(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &destStaging, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction) +{ + ANGLE_TRY(initResources(context)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + TextureHelper11 sourceStaging; + ANGLE_TRY(mRenderer->createStagingTexture(context, ResourceType::Texture2D, + source.getFormatSet(), sourceSize, + StagingAccess::READ, &sourceStaging)); + + deviceContext->CopySubresourceRegion(sourceStaging.get(), 0, 0, 0, 0, source.get(), + sourceSubresource, nullptr); + + D3D11_MAPPED_SUBRESOURCE sourceMapping; + ANGLE_TRY( + mRenderer->mapResource(context, sourceStaging.get(), 0, D3D11_MAP_READ, 0, &sourceMapping)); + + D3D11_MAPPED_SUBRESOURCE destMapping; + angle::Result error = + mRenderer->mapResource(context, destStaging.get(), 0, D3D11_MAP_WRITE, 0, &destMapping); + if (error == angle::Result::Stop) + { + deviceContext->Unmap(sourceStaging.get(), 0); + return error; + } + + // Clip dest area to the destination size + gl::Rectangle clipRect = gl::Rectangle(0, 0, destSize.width, destSize.height); + + // Clip dest area to the scissor + if (scissor) + { + if (!gl::ClipRectangle(clipRect, *scissor, &clipRect)) + { + return angle::Result::Continue; + } + } + + convertFunction(sourceArea, destArea, clipRect, sourceSize, sourceMapping.RowPitch, + destMapping.RowPitch, readOffset, writeOffset, copySize, srcPixelStride, + destPixelStride, static_cast<const uint8_t *>(sourceMapping.pData), + static_cast<uint8_t *>(destMapping.pData)); + + deviceContext->Unmap(sourceStaging.get(), 0); + deviceContext->Unmap(destStaging.get(), 0); + + return angle::Result::Continue; +} + +angle::Result Blit11::copyAndConvert(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction) +{ + ANGLE_TRY(initResources(context)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // HACK: Create the destination staging buffer as a read/write texture so + // ID3D11DevicContext::UpdateSubresource can be called + // using it's mapped data as a source + TextureHelper11 destStaging; + ANGLE_TRY(mRenderer->createStagingTexture(context, ResourceType::Texture2D, dest.getFormatSet(), + destSize, StagingAccess::READ_WRITE, &destStaging)); + + deviceContext->CopySubresourceRegion(destStaging.get(), 0, 0, 0, 0, dest.get(), destSubresource, + nullptr); + + ANGLE_TRY(copyAndConvertImpl(context, source, sourceSubresource, sourceArea, sourceSize, + destStaging, destArea, destSize, scissor, readOffset, writeOffset, + copySize, srcPixelStride, destPixelStride, convertFunction)); + + // Work around timeouts/TDRs in older NVIDIA drivers. + if (mRenderer->getFeatures().depthStencilBlitExtraCopy.enabled) + { + D3D11_MAPPED_SUBRESOURCE mapped; + ANGLE_TRY( + mRenderer->mapResource(context, destStaging.get(), 0, D3D11_MAP_READ, 0, &mapped)); + deviceContext->UpdateSubresource(dest.get(), destSubresource, nullptr, mapped.pData, + mapped.RowPitch, mapped.DepthPitch); + deviceContext->Unmap(destStaging.get(), 0); + } + else + { + deviceContext->CopySubresourceRegion(dest.get(), destSubresource, 0, 0, 0, + destStaging.get(), 0, nullptr); + } + + return angle::Result::Continue; +} + +angle::Result Blit11::addBlitShaderToMap(const gl::Context *context, + BlitShaderType blitShaderType, + ShaderDimension dimension, + const ShaderData &shaderData, + const char *name) +{ + ASSERT(mBlitShaderMap.find(blitShaderType) == mBlitShaderMap.end()); + + d3d11::PixelShader ps; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), shaderData, &ps)); + ps.setInternalName(name); + + Shader shader; + shader.dimension = dimension; + shader.pixelShader = std::move(ps); + + mBlitShaderMap[blitShaderType] = std::move(shader); + return angle::Result::Continue; +} + +angle::Result Blit11::addSwizzleShaderToMap(const gl::Context *context, + SwizzleShaderType swizzleShaderType, + ShaderDimension dimension, + const ShaderData &shaderData, + const char *name) +{ + ASSERT(mSwizzleShaderMap.find(swizzleShaderType) == mSwizzleShaderMap.end()); + + d3d11::PixelShader ps; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), shaderData, &ps)); + ps.setInternalName(name); + + Shader shader; + shader.dimension = dimension; + shader.pixelShader = std::move(ps); + + mSwizzleShaderMap[swizzleShaderType] = std::move(shader); + return angle::Result::Continue; +} + +void Blit11::clearShaderMap() +{ + mBlitShaderMap.clear(); + mSwizzleShaderMap.clear(); +} + +Blit11::BlitShaderOperation Blit11::getBlitShaderOperation(GLenum destinationFormat, + GLenum sourceFormat, + bool isSrcSigned, + bool isDestSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + GLenum destTypeForDownsampling) +{ + bool floatToIntBlit = + !gl::IsIntegerFormat(sourceFormat) && gl::IsIntegerFormat(destinationFormat); + + if (isSrcSigned) + { + ASSERT(!unpackPremultiplyAlpha && !unpackUnmultiplyAlpha); + switch (destinationFormat) + { + case GL_RGBA_INTEGER: + return RGBAI; + case GL_RGB_INTEGER: + return RGBI; + case GL_RG_INTEGER: + return RGI; + case GL_RED_INTEGER: + return RI; + default: + UNREACHABLE(); + return OPERATION_INVALID; + } + } + else if (isDestSigned) + { + ASSERT(floatToIntBlit); + + switch (destinationFormat) + { + case GL_RGBA_INTEGER: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBAF_TOI; + } + return unpackPremultiplyAlpha ? RGBAF_TOI_PREMULTIPLY : RGBAF_TOI_UNMULTIPLY; + case GL_RGB_INTEGER: + case GL_RG_INTEGER: + case GL_RED_INTEGER: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBF_TOI; + } + return unpackPremultiplyAlpha ? RGBF_TOI_PREMULTIPLY : RGBF_TOI_UNMULTIPLY; + default: + UNREACHABLE(); + return OPERATION_INVALID; + } + } + else + { + // Check for the downsample formats first + switch (destTypeForDownsampling) + { + case GL_UNSIGNED_SHORT_4_4_4_4: + ASSERT(destinationFormat == GL_RGBA && !floatToIntBlit); + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBAF_4444; + } + else if (unpackPremultiplyAlpha) + { + return RGBAF_4444_PREMULTIPLY; + } + else + { + return RGBAF_4444_UNMULTIPLY; + } + + case GL_UNSIGNED_SHORT_5_6_5: + ASSERT(destinationFormat == GL_RGB && !floatToIntBlit); + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBF_565; + } + else + { + return unpackPremultiplyAlpha ? RGBF_565_PREMULTIPLY : RGBF_565_UNMULTIPLY; + } + case GL_UNSIGNED_SHORT_5_5_5_1: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBAF_5551; + } + else + { + return unpackPremultiplyAlpha ? RGBAF_5551_PREMULTIPLY : RGBAF_5551_UNMULTIPLY; + } + + default: + // By default, use the regular passthrough/multiply/unmultiply shaders. The above + // shaders are only needed for some emulated texture formats. + break; + } + + if (unpackPremultiplyAlpha != unpackUnmultiplyAlpha || floatToIntBlit) + { + switch (destinationFormat) + { + case GL_RGBA: + case GL_BGRA_EXT: + ASSERT(!floatToIntBlit); + return unpackPremultiplyAlpha ? RGBAF_PREMULTIPLY : RGBAF_UNMULTIPLY; + case GL_RGB: + case GL_RG: + case GL_RED: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBF_TOUI; + } + else + { + return unpackPremultiplyAlpha ? RGBF_PREMULTIPLY : RGBF_UNMULTIPLY; + } + case GL_RGBA_INTEGER: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBAF_TOUI; + } + else + { + return unpackPremultiplyAlpha ? RGBAF_TOUI_PREMULTIPLY + : RGBAF_TOUI_UNMULTIPLY; + } + case GL_RGB_INTEGER: + case GL_RG_INTEGER: + case GL_RED_INTEGER: + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha) + { + return RGBF_TOUI; + } + else + { + return unpackPremultiplyAlpha ? RGBF_TOUI_PREMULTIPLY + : RGBF_TOUI_UNMULTIPLY; + } + case GL_LUMINANCE: + ASSERT(!floatToIntBlit); + return unpackPremultiplyAlpha ? LUMAF_PREMULTIPLY : LUMAF_UNMULTIPLY; + + case GL_LUMINANCE_ALPHA: + ASSERT(!floatToIntBlit); + return unpackPremultiplyAlpha ? LUMAALPHAF_PREMULTIPLY : LUMAALPHAF_UNMULTIPLY; + case GL_ALPHA: + return ALPHA; + default: + UNREACHABLE(); + return OPERATION_INVALID; + } + } + else + { + switch (destinationFormat) + { + case GL_RGBA: + return RGBAF; + case GL_RGBA_INTEGER: + return RGBAUI; + case GL_BGRA_EXT: + return BGRAF; + case GL_RGB: + return RGBF; + case GL_RGB_INTEGER: + return RGBUI; + case GL_RG: + return RGF; + case GL_RG_INTEGER: + return RGUI; + case GL_RED: + return RF; + case GL_RED_INTEGER: + return RUI; + case GL_ALPHA: + return ALPHA; + case GL_LUMINANCE: + return LUMA; + case GL_LUMINANCE_ALPHA: + return LUMAALPHA; + default: + UNREACHABLE(); + return OPERATION_INVALID; + } + } + } +} + +angle::Result Blit11::getBlitShader(const gl::Context *context, + GLenum destFormat, + GLenum sourceFormat, + bool isSrcSigned, + bool isDestSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + GLenum destTypeForDownsampling, + ShaderDimension dimension, + const Shader **shader) +{ + BlitShaderOperation blitShaderOperation = OPERATION_INVALID; + + blitShaderOperation = getBlitShaderOperation(destFormat, sourceFormat, isSrcSigned, + isDestSigned, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha, destTypeForDownsampling); + + BlitShaderType blitShaderType = BLITSHADER_INVALID; + + blitShaderType = getBlitShaderType(blitShaderOperation, dimension); + + ANGLE_CHECK_HR(GetImplAs<Context11>(context), blitShaderType != BLITSHADER_INVALID, + "Internal blit shader type mismatch", E_FAIL); + + auto blitShaderIt = mBlitShaderMap.find(blitShaderType); + if (blitShaderIt != mBlitShaderMap.end()) + { + *shader = &blitShaderIt->second; + return angle::Result::Continue; + } + + ASSERT(dimension == SHADER_2D || mRenderer->isES3Capable()); + + ANGLE_TRY(mapBlitShader(context, blitShaderType)); + + blitShaderIt = mBlitShaderMap.find(blitShaderType); + ASSERT(blitShaderIt != mBlitShaderMap.end()); + *shader = &blitShaderIt->second; + return angle::Result::Continue; +} + +angle::Result Blit11::getSwizzleShader(const gl::Context *context, + GLenum type, + D3D11_SRV_DIMENSION viewDimension, + const Shader **shader) +{ + SwizzleShaderType swizzleShaderType = GetSwizzleShaderType(type, viewDimension); + + ANGLE_CHECK_HR(GetImplAs<Context11>(context), swizzleShaderType != SWIZZLESHADER_INVALID, + "Swizzle shader type not found", E_FAIL); + + auto swizzleShaderIt = mSwizzleShaderMap.find(swizzleShaderType); + if (swizzleShaderIt != mSwizzleShaderMap.end()) + { + *shader = &swizzleShaderIt->second; + return angle::Result::Continue; + } + + // Swizzling shaders (OpenGL ES 3+) + ASSERT(mRenderer->isES3Capable()); + + switch (swizzleShaderType) + { + case SWIZZLESHADER_2D_FLOAT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_2D, + ShaderData(g_PS_SwizzleF2D), + "Blit11 2D F swizzle pixel shader")); + break; + case SWIZZLESHADER_2D_UINT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_2D, + ShaderData(g_PS_SwizzleUI2D), + "Blit11 2D UI swizzle pixel shader")); + break; + case SWIZZLESHADER_2D_INT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_2D, + ShaderData(g_PS_SwizzleI2D), + "Blit11 2D I swizzle pixel shader")); + break; + case SWIZZLESHADER_CUBE_FLOAT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleF2DArray), + "Blit11 2D Cube F swizzle pixel shader")); + break; + case SWIZZLESHADER_CUBE_UINT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleUI2DArray), + "Blit11 2D Cube UI swizzle pixel shader")); + break; + case SWIZZLESHADER_CUBE_INT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleI2DArray), + "Blit11 2D Cube I swizzle pixel shader")); + break; + case SWIZZLESHADER_3D_FLOAT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleF3D), + "Blit11 3D F swizzle pixel shader")); + break; + case SWIZZLESHADER_3D_UINT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleUI3D), + "Blit11 3D UI swizzle pixel shader")); + break; + case SWIZZLESHADER_3D_INT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleI3D), + "Blit11 3D I swizzle pixel shader")); + break; + case SWIZZLESHADER_ARRAY_FLOAT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleF2DArray), + "Blit11 2D Array F swizzle pixel shader")); + break; + case SWIZZLESHADER_ARRAY_UINT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleUI2DArray), + "Blit11 2D Array UI swizzle pixel shader")); + break; + case SWIZZLESHADER_ARRAY_INT: + ANGLE_TRY(addSwizzleShaderToMap(context, swizzleShaderType, SHADER_3D, + ShaderData(g_PS_SwizzleI2DArray), + "Blit11 2D Array I swizzle pixel shader")); + break; + default: + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + } + + swizzleShaderIt = mSwizzleShaderMap.find(swizzleShaderType); + ASSERT(swizzleShaderIt != mSwizzleShaderMap.end()); + *shader = &swizzleShaderIt->second; + return angle::Result::Continue; +} + +angle::Result Blit11::resolveDepth(const gl::Context *context, + RenderTarget11 *depth, + TextureHelper11 *textureOut) +{ + ANGLE_TRY(initResources(context)); + + // Multisampled depth stencil SRVs are not available in feature level 10.0 + ASSERT(mRenderer->getRenderer11DeviceCaps().featureLevel > D3D_FEATURE_LEVEL_10_0); + + const auto &extents = depth->getExtents(); + auto *deviceContext = mRenderer->getDeviceContext(); + auto *stateManager = mRenderer->getStateManager(); + + ANGLE_TRY(initResolveDepthOnly(context, depth->getFormatSet(), extents)); + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mResolveDepthStencilVS.resolve(context11, mRenderer)); + ANGLE_TRY(mResolveDepthPS.resolve(context11, mRenderer)); + + // Apply the necessary state changes to the D3D11 immediate device context. + stateManager->setInputLayout(nullptr); + stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr, + &mResolveDepthPS.getObj()); + stateManager->setRasterizerState(nullptr); + stateManager->setDepthStencilState(&mDepthStencilState, 0xFFFFFFFF); + stateManager->setRenderTargets(nullptr, 0, mResolvedDepthDSView.get()); + stateManager->setSimpleBlendState(nullptr); + stateManager->setSimpleViewport(extents); + + // Set the viewport + const d3d11::SharedSRV *srv; + ANGLE_TRY(depth->getShaderResourceView(context, &srv)); + + stateManager->setShaderResourceShared(gl::ShaderType::Fragment, 0, srv); + + // Trigger the blit on the GPU. + deviceContext->Draw(6, 0); + + *textureOut = mResolvedDepth; + return angle::Result::Continue; +} + +angle::Result Blit11::initResolveDepthOnly(const gl::Context *context, + const d3d11::Format &format, + const gl::Extents &extents) +{ + if (mResolvedDepth.valid() && extents == mResolvedDepth.getExtents() && + format.texFormat == mResolvedDepth.getFormat()) + { + return angle::Result::Continue; + } + + D3D11_TEXTURE2D_DESC textureDesc; + textureDesc.Width = extents.width; + textureDesc.Height = extents.height; + textureDesc.MipLevels = 1; + textureDesc.ArraySize = 1; + textureDesc.Format = format.texFormat; + textureDesc.SampleDesc.Count = 1; + textureDesc.SampleDesc.Quality = 0; + textureDesc.Usage = D3D11_USAGE_DEFAULT; + textureDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE; + textureDesc.CPUAccessFlags = 0; + textureDesc.MiscFlags = 0; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mRenderer->allocateTexture(context11, textureDesc, format, &mResolvedDepth)); + mResolvedDepth.setInternalName("Blit11::mResolvedDepth"); + + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Flags = 0; + dsvDesc.Format = format.dsvFormat; + dsvDesc.Texture2D.MipSlice = 0; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + + ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, mResolvedDepth.get(), + &mResolvedDepthDSView)); + mResolvedDepthDSView.setInternalName("Blit11::mResolvedDepthDSView"); + + // Possibly D3D11 bug or undefined behaviour: Clear the DSV so that our first render + // works as expected. Otherwise the results of the first use seem to be incorrect. + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->ClearDepthStencilView(mResolvedDepthDSView.get(), D3D11_CLEAR_DEPTH, 1.0f, 0); + + return angle::Result::Continue; +} + +angle::Result Blit11::initResolveDepthStencil(const gl::Context *context, + const gl::Extents &extents) +{ + // Check if we need to recreate depth stencil view + if (mResolvedDepthStencil.valid() && extents == mResolvedDepthStencil.getExtents()) + { + ASSERT(mResolvedDepthStencil.getFormat() == DXGI_FORMAT_R32G32_FLOAT); + return angle::Result::Continue; + } + + if (mResolvedDepthStencil.valid()) + { + releaseResolveDepthStencilResources(); + } + + const auto &formatSet = d3d11::Format::Get(GL_RG32F, mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC textureDesc; + textureDesc.Width = extents.width; + textureDesc.Height = extents.height; + textureDesc.MipLevels = 1; + textureDesc.ArraySize = 1; + textureDesc.Format = formatSet.texFormat; + textureDesc.SampleDesc.Count = 1; + textureDesc.SampleDesc.Quality = 0; + textureDesc.Usage = D3D11_USAGE_DEFAULT; + textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET; + textureDesc.CPUAccessFlags = 0; + textureDesc.MiscFlags = 0; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY( + mRenderer->allocateTexture(context11, textureDesc, formatSet, &mResolvedDepthStencil)); + mResolvedDepthStencil.setInternalName("Blit11::mResolvedDepthStencil"); + + ANGLE_TRY(mRenderer->allocateResourceNoDesc(context11, mResolvedDepthStencil.get(), + &mResolvedDepthStencilRTView)); + mResolvedDepthStencilRTView.setInternalName("Blit11::mResolvedDepthStencilRTView"); + + return angle::Result::Continue; +} + +angle::Result Blit11::resolveStencil(const gl::Context *context, + RenderTarget11 *depthStencil, + bool alsoDepth, + TextureHelper11 *textureOut) +{ + ANGLE_TRY(initResources(context)); + + // Multisampled depth stencil SRVs are not available in feature level 10.0 + ASSERT(mRenderer->getRenderer11DeviceCaps().featureLevel > D3D_FEATURE_LEVEL_10_0); + + const auto &extents = depthStencil->getExtents(); + + ANGLE_TRY(initResolveDepthStencil(context, extents)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + auto *stateManager = mRenderer->getStateManager(); + ID3D11Resource *stencilResource = depthStencil->getTexture().get(); + + // Check if we need to re-create the stencil SRV. + if (mStencilSRV.valid()) + { + ID3D11Resource *priorResource = nullptr; + mStencilSRV.get()->GetResource(&priorResource); + + if (stencilResource != priorResource) + { + mStencilSRV.reset(); + } + + SafeRelease(priorResource); + } + + Context11 *context11 = GetImplAs<Context11>(context); + + if (!mStencilSRV.valid()) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srViewDesc; + srViewDesc.Format = GetStencilSRVFormat(depthStencil->getFormatSet()); + srViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; + + ANGLE_TRY( + mRenderer->allocateResource(context11, srViewDesc, stencilResource, &mStencilSRV)); + mStencilSRV.setInternalName("Blit11::mStencilSRV"); + } + + // Notify the Renderer that all state should be invalidated. + ANGLE_TRY(mResolveDepthStencilVS.resolve(context11, mRenderer)); + + // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then + // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil + // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3. + const d3d11::PixelShader *pixelShader = nullptr; + if (alsoDepth) + { + ANGLE_TRY(mResolveDepthStencilPS.resolve(context11, mRenderer)); + pixelShader = &mResolveDepthStencilPS.getObj(); + } + else + { + ANGLE_TRY(mResolveStencilPS.resolve(context11, mRenderer)); + pixelShader = &mResolveStencilPS.getObj(); + } + + // Apply the necessary state changes to the D3D11 immediate device context. + stateManager->setInputLayout(nullptr); + stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr, pixelShader); + stateManager->setRasterizerState(nullptr); + stateManager->setDepthStencilState(nullptr, 0xFFFFFFFF); + stateManager->setRenderTarget(mResolvedDepthStencilRTView.get(), nullptr); + stateManager->setSimpleBlendState(nullptr); + + // Set the viewport + stateManager->setSimpleViewport(extents); + const d3d11::SharedSRV *srv; + ANGLE_TRY(depthStencil->getShaderResourceView(context, &srv)); + stateManager->setShaderResourceShared(gl::ShaderType::Fragment, 0, srv); + stateManager->setShaderResource(gl::ShaderType::Fragment, 1, &mStencilSRV); + + // Trigger the blit on the GPU. + deviceContext->Draw(6, 0); + + gl::Box copyBox(0, 0, 0, extents.width, extents.height, 1); + + ANGLE_TRY(mRenderer->createStagingTexture(context, ResourceType::Texture2D, + depthStencil->getFormatSet(), extents, + StagingAccess::READ_WRITE, textureOut)); + + const auto ©Function = GetCopyDepthStencilFunction(depthStencil->getInternalFormat()); + const auto &dsFormatSet = depthStencil->getFormatSet(); + const auto &dsDxgiInfo = d3d11::GetDXGIFormatSizeInfo(dsFormatSet.texFormat); + + ANGLE_TRY(copyAndConvertImpl(context, mResolvedDepthStencil, 0, copyBox, extents, *textureOut, + copyBox, extents, nullptr, 0, 0, 0, 8u, dsDxgiInfo.pixelBytes, + copyFunction)); + + return angle::Result::Continue; +} + +void Blit11::releaseResolveDepthStencilResources() +{ + mStencilSRV.reset(); + mResolvedDepthStencilRTView.reset(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.h new file mode 100644 index 0000000000..cef491137d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11.h @@ -0,0 +1,300 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Blit11.cpp: Texture copy utility class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_BLIT11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_BLIT11_H_ + +#include "common/angleutils.h" +#include "libANGLE/Error.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include <map> + +namespace rx +{ +class Renderer11; + +class Blit11 : angle::NonCopyable +{ + public: + explicit Blit11(Renderer11 *renderer); + ~Blit11(); + + angle::Result swizzleTexture(const gl::Context *context, + const d3d11::SharedSRV &source, + const d3d11::RenderTargetView &dest, + const gl::Extents &size, + const gl::SwizzleState &swizzleTarget); + + // Set destTypeForDownsampling to GL_NONE to skip downsampling + angle::Result copyTexture(const gl::Context *context, + const d3d11::SharedSRV &source, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + GLenum sourceFormat, + const d3d11::RenderTargetView &dest, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + GLenum destFormat, + GLenum destTypeForDownsampling, + GLenum filter, + bool maskOffAlpha, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha); + + angle::Result copyStencil(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor); + + angle::Result copyDepth(const gl::Context *context, + const d3d11::SharedSRV &source, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const d3d11::DepthStencilView &dest, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor); + + angle::Result copyDepthStencil(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor); + + angle::Result resolveDepth(const gl::Context *context, + RenderTarget11 *depth, + TextureHelper11 *textureOut); + + angle::Result resolveStencil(const gl::Context *context, + RenderTarget11 *depthStencil, + bool alsoDepth, + TextureHelper11 *textureOut); + + using BlitConvertFunction = void(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clipRect, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData); + + private: + enum BlitShaderOperation : unsigned int; + enum BlitShaderType : unsigned int; + enum SwizzleShaderType + { + SWIZZLESHADER_INVALID, + SWIZZLESHADER_2D_FLOAT, + SWIZZLESHADER_2D_UINT, + SWIZZLESHADER_2D_INT, + SWIZZLESHADER_CUBE_FLOAT, + SWIZZLESHADER_CUBE_UINT, + SWIZZLESHADER_CUBE_INT, + SWIZZLESHADER_3D_FLOAT, + SWIZZLESHADER_3D_UINT, + SWIZZLESHADER_3D_INT, + SWIZZLESHADER_ARRAY_FLOAT, + SWIZZLESHADER_ARRAY_UINT, + SWIZZLESHADER_ARRAY_INT, + }; + + typedef void (*WriteVertexFunction)(const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const gl::Box &destArea, + const gl::Extents &destSize, + void *outVertices, + unsigned int *outStride, + unsigned int *outVertexCount, + D3D11_PRIMITIVE_TOPOLOGY *outTopology); + + enum ShaderDimension + { + SHADER_INVALID, + SHADER_2D, + SHADER_3D, + SHADER_2DARRAY + }; + + struct Shader + { + Shader(); + Shader(Shader &&other); + ~Shader(); + Shader &operator=(Shader &&other); + + ShaderDimension dimension; + d3d11::PixelShader pixelShader; + }; + + struct ShaderSupport + { + const d3d11::InputLayout *inputLayout; + const d3d11::VertexShader *vertexShader; + const d3d11::GeometryShader *geometryShader; + WriteVertexFunction vertexWriteFunction; + }; + + angle::Result initResources(const gl::Context *context); + + angle::Result getShaderSupport(const gl::Context *context, + const Shader &shader, + ShaderSupport *supportOut); + + static BlitShaderOperation getBlitShaderOperation(GLenum destinationFormat, + GLenum sourceFormat, + bool isSrcSigned, + bool isDestSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + GLenum destTypeForDownsampling); + + static BlitShaderType getBlitShaderType(BlitShaderOperation operation, + ShaderDimension dimension); + + static SwizzleShaderType GetSwizzleShaderType(GLenum type, D3D11_SRV_DIMENSION dimensionality); + + angle::Result copyDepthStencilImpl(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + bool stencilOnly); + + angle::Result copyAndConvertImpl(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &destStaging, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction); + + angle::Result copyAndConvert(const gl::Context *context, + const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction); + + angle::Result mapBlitShader(const gl::Context *context, BlitShaderType blitShaderType); + angle::Result addBlitShaderToMap(const gl::Context *context, + BlitShaderType blitShaderType, + ShaderDimension dimension, + const ShaderData &shaderData, + const char *name); + + angle::Result getBlitShader(const gl::Context *context, + GLenum destFormat, + GLenum sourceFormat, + bool isSrcSigned, + bool isDestSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + GLenum destTypeForDownsampling, + ShaderDimension dimension, + const Shader **shaderOut); + angle::Result getSwizzleShader(const gl::Context *context, + GLenum type, + D3D11_SRV_DIMENSION viewDimension, + const Shader **shaderOut); + + angle::Result addSwizzleShaderToMap(const gl::Context *context, + SwizzleShaderType swizzleShaderType, + ShaderDimension dimension, + const ShaderData &shaderData, + const char *name); + + void clearShaderMap(); + void releaseResolveDepthStencilResources(); + angle::Result initResolveDepthOnly(const gl::Context *context, + const d3d11::Format &format, + const gl::Extents &extents); + angle::Result initResolveDepthStencil(const gl::Context *context, const gl::Extents &extents); + + Renderer11 *mRenderer; + + std::map<BlitShaderType, Shader> mBlitShaderMap; + std::map<SwizzleShaderType, Shader> mSwizzleShaderMap; + + bool mResourcesInitialized; + d3d11::Buffer mVertexBuffer; + d3d11::SamplerState mPointSampler; + d3d11::SamplerState mLinearSampler; + d3d11::RasterizerState mScissorEnabledRasterizerState; + d3d11::RasterizerState mScissorDisabledRasterizerState; + d3d11::DepthStencilState mDepthStencilState; + + d3d11::LazyInputLayout mQuad2DIL; + d3d11::LazyShader<ID3D11VertexShader> mQuad2DVS; + d3d11::LazyShader<ID3D11PixelShader> mDepthPS; + + d3d11::LazyInputLayout mQuad3DIL; + d3d11::LazyShader<ID3D11VertexShader> mQuad3DVS; + d3d11::LazyShader<ID3D11GeometryShader> mQuad3DGS; + + d3d11::LazyBlendState mAlphaMaskBlendState; + + d3d11::Buffer mSwizzleCB; + + d3d11::LazyShader<ID3D11VertexShader> mResolveDepthStencilVS; + d3d11::LazyShader<ID3D11PixelShader> mResolveDepthPS; + d3d11::LazyShader<ID3D11PixelShader> mResolveDepthStencilPS; + d3d11::LazyShader<ID3D11PixelShader> mResolveStencilPS; + d3d11::ShaderResourceView mStencilSRV; + TextureHelper11 mResolvedDepthStencil; + d3d11::RenderTargetView mResolvedDepthStencilRTView; + TextureHelper11 mResolvedDepth; + d3d11::DepthStencilView mResolvedDepthDSView; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_BLIT11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc new file mode 100644 index 0000000000..64d8106a18 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Blit11Helper_autogen.inc @@ -0,0 +1,1575 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by gen_blit11helper.py. +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Blit11Helper_autogen.inc: +// Defines and retrieves blitshaders for the D3D11 backend. + +namespace +{ +// Include inline shaders in the anonymous namespace to make sure no symbols are exported +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrougha2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_4444_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d_565_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_5551_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_4444_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d_565_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_5551_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_3d_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2darray11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayi11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayi11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayi11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayui11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayi11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_4444_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray_565_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_5551_11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2darray_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2darray_ps.h" +} // namespace + +enum Blit11::BlitShaderOperation : unsigned int +{ + RGBAF, + BGRAF, + RGBF, + RGF, + RF, + ALPHA, + LUMA, + LUMAALPHA, + RGBAUI, + RGBAI, + RGBUI, + RGBI, + RGUI, + RGI, + RUI, + RI, + RGBAF_PREMULTIPLY, + RGBAF_UNMULTIPLY, + RGBF_PREMULTIPLY, + RGBF_UNMULTIPLY, + RGBAF_TOUI, + RGBAF_TOUI_PREMULTIPLY, + RGBAF_TOUI_UNMULTIPLY, + RGBF_TOUI, + RGBF_TOUI_PREMULTIPLY, + RGBF_TOUI_UNMULTIPLY, + RGBAF_TOI, + RGBAF_TOI_PREMULTIPLY, + RGBAF_TOI_UNMULTIPLY, + RGBF_TOI, + RGBF_TOI_PREMULTIPLY, + RGBF_TOI_UNMULTIPLY, + LUMAF_PREMULTIPLY, + LUMAF_UNMULTIPLY, + LUMAALPHAF_PREMULTIPLY, + LUMAALPHAF_UNMULTIPLY, + RGBAF_4444, + RGBAF_4444_PREMULTIPLY, + RGBAF_4444_UNMULTIPLY, + RGBF_565, + RGBF_565_PREMULTIPLY, + RGBF_565_UNMULTIPLY, + RGBAF_5551, + RGBAF_5551_PREMULTIPLY, + RGBAF_5551_UNMULTIPLY, + OPERATION_INVALID +}; + +enum Blit11::BlitShaderType : unsigned int +{ + BLITSHADER_2D_RGBAF, + BLITSHADER_2D_BGRAF, + BLITSHADER_2D_RGBF, + BLITSHADER_2D_RGF, + BLITSHADER_2D_RF, + BLITSHADER_2D_ALPHA, + BLITSHADER_2D_LUMA, + BLITSHADER_2D_LUMAALPHA, + BLITSHADER_2D_RGBAUI, + BLITSHADER_2D_RGBAI, + BLITSHADER_2D_RGBUI, + BLITSHADER_2D_RGBI, + BLITSHADER_2D_RGUI, + BLITSHADER_2D_RGI, + BLITSHADER_2D_RUI, + BLITSHADER_2D_RI, + BLITSHADER_2D_RGBAF_PREMULTIPLY, + BLITSHADER_2D_RGBAF_UNMULTIPLY, + BLITSHADER_2D_RGBF_PREMULTIPLY, + BLITSHADER_2D_RGBF_UNMULTIPLY, + BLITSHADER_2D_RGBAF_TOUI, + BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY, + BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY, + BLITSHADER_2D_RGBF_TOUI, + BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY, + BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY, + BLITSHADER_2D_LUMAF_PREMULTIPLY, + BLITSHADER_2D_LUMAF_UNMULTIPLY, + BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY, + BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY, + BLITSHADER_2D_RGBAF_4444, + BLITSHADER_2D_RGBAF_4444_PREMULTIPLY, + BLITSHADER_2D_RGBAF_4444_UNMULTIPLY, + BLITSHADER_2D_RGBF_565, + BLITSHADER_2D_RGBF_565_PREMULTIPLY, + BLITSHADER_2D_RGBF_565_UNMULTIPLY, + BLITSHADER_2D_RGBAF_5551, + BLITSHADER_2D_RGBAF_5551_PREMULTIPLY, + BLITSHADER_2D_RGBAF_5551_UNMULTIPLY, + BLITSHADER_3D_RGBAF, + BLITSHADER_3D_BGRAF, + BLITSHADER_3D_RGBF, + BLITSHADER_3D_RGF, + BLITSHADER_3D_RF, + BLITSHADER_3D_ALPHA, + BLITSHADER_3D_LUMA, + BLITSHADER_3D_LUMAALPHA, + BLITSHADER_3D_RGBAUI, + BLITSHADER_3D_RGBAI, + BLITSHADER_3D_RGBUI, + BLITSHADER_3D_RGBI, + BLITSHADER_3D_RGUI, + BLITSHADER_3D_RGI, + BLITSHADER_3D_RUI, + BLITSHADER_3D_RI, + BLITSHADER_3D_RGBAF_PREMULTIPLY, + BLITSHADER_3D_RGBAF_UNMULTIPLY, + BLITSHADER_3D_RGBF_PREMULTIPLY, + BLITSHADER_3D_RGBF_UNMULTIPLY, + BLITSHADER_3D_RGBAF_TOUI, + BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY, + BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY, + BLITSHADER_3D_RGBF_TOUI, + BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY, + BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY, + BLITSHADER_3D_RGBAF_TOI, + BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY, + BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY, + BLITSHADER_3D_RGBF_TOI, + BLITSHADER_3D_RGBF_TOI_PREMULTIPLY, + BLITSHADER_3D_RGBF_TOI_UNMULTIPLY, + BLITSHADER_3D_LUMAF_PREMULTIPLY, + BLITSHADER_3D_LUMAF_UNMULTIPLY, + BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY, + BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY, + BLITSHADER_3D_RGBAF_4444, + BLITSHADER_3D_RGBAF_4444_PREMULTIPLY, + BLITSHADER_3D_RGBAF_4444_UNMULTIPLY, + BLITSHADER_3D_RGBF_565, + BLITSHADER_3D_RGBF_565_PREMULTIPLY, + BLITSHADER_3D_RGBF_565_UNMULTIPLY, + BLITSHADER_3D_RGBAF_5551, + BLITSHADER_3D_RGBAF_5551_PREMULTIPLY, + BLITSHADER_3D_RGBAF_5551_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBAF, + BLITSHADER_2DARRAY_BGRAF, + BLITSHADER_2DARRAY_RGBF, + BLITSHADER_2DARRAY_RGF, + BLITSHADER_2DARRAY_RF, + BLITSHADER_2DARRAY_ALPHA, + BLITSHADER_2DARRAY_LUMA, + BLITSHADER_2DARRAY_LUMAALPHA, + BLITSHADER_2DARRAY_RGBAUI, + BLITSHADER_2DARRAY_RGBAI, + BLITSHADER_2DARRAY_RGBUI, + BLITSHADER_2DARRAY_RGBI, + BLITSHADER_2DARRAY_RGUI, + BLITSHADER_2DARRAY_RGI, + BLITSHADER_2DARRAY_RUI, + BLITSHADER_2DARRAY_RI, + BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBF_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBF_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_TOUI, + BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBF_TOUI, + BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_TOI, + BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBF_TOI, + BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY, + BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY, + BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY, + BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY, + BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_4444, + BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBF_565, + BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_5551, + BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY, + BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY, + BLITSHADER_INVALID +}; + +Blit11::BlitShaderType Blit11::getBlitShaderType(BlitShaderOperation operation, ShaderDimension dimension) +{ + switch(operation) + { + case RGBAF: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF; + case SHADER_3D: + return BLITSHADER_3D_RGBAF; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case BGRAF: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_BGRAF; + case SHADER_3D: + return BLITSHADER_3D_BGRAF; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_BGRAF; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF; + case SHADER_3D: + return BLITSHADER_3D_RGBF; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGF: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGF; + case SHADER_3D: + return BLITSHADER_3D_RGF; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGF; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RF: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RF; + case SHADER_3D: + return BLITSHADER_3D_RF; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RF; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case ALPHA: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_ALPHA; + case SHADER_3D: + return BLITSHADER_3D_ALPHA; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_ALPHA; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMA: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMA; + case SHADER_3D: + return BLITSHADER_3D_LUMA; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMA; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMAALPHA: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMAALPHA; + case SHADER_3D: + return BLITSHADER_3D_LUMAALPHA; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMAALPHA; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAUI; + case SHADER_3D: + return BLITSHADER_3D_RGBAUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAI; + case SHADER_3D: + return BLITSHADER_3D_RGBAI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBUI; + case SHADER_3D: + return BLITSHADER_3D_RGBUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBI; + case SHADER_3D: + return BLITSHADER_3D_RGBI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGUI; + case SHADER_3D: + return BLITSHADER_3D_RGUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGI; + case SHADER_3D: + return BLITSHADER_3D_RGI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RUI; + case SHADER_3D: + return BLITSHADER_3D_RUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RI; + case SHADER_3D: + return BLITSHADER_3D_RI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_TOUI; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOUI_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOUI_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOUI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_TOUI; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOUI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOUI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOUI_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOUI_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOI_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_TOI_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOI: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOI; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOI; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOI_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOI_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_TOI_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_INVALID; + case SHADER_3D: + return BLITSHADER_3D_RGBF_TOI_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMAF_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMAF_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_LUMAF_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMAF_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMAF_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_LUMAF_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMAALPHAF_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case LUMAALPHAF_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_4444: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_4444; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_4444; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_4444; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_4444_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_4444_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_4444_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_4444_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_4444_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_4444_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_565: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_565; + case SHADER_3D: + return BLITSHADER_3D_RGBF_565; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_565; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_565_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_565_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_565_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBF_565_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBF_565_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBF_565_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_5551: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_5551; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_5551; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_5551; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_5551_PREMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_5551_PREMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_5551_PREMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + case RGBAF_5551_UNMULTIPLY: + switch (dimension) + { + case SHADER_2D: + return BLITSHADER_2D_RGBAF_5551_UNMULTIPLY; + case SHADER_3D: + return BLITSHADER_3D_RGBAF_5551_UNMULTIPLY; + case SHADER_2DARRAY: + return BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } +} + +angle::Result Blit11::mapBlitShader(const gl::Context *context, + BlitShaderType blitShaderType) +{ + switch(blitShaderType) + { + case BLITSHADER_2D_RGBAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2D), + "Blit11 2D PassthroughRGBA2D pixel shader")); + break; + case BLITSHADER_2D_BGRAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2D), + "Blit11 2D PassthroughRGBA2D pixel shader")); + break; + case BLITSHADER_2D_RGBF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGB2D), + "Blit11 2D PassthroughRGB2D pixel shader")); + break; + case BLITSHADER_2D_RGF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRG2D), + "Blit11 2D PassthroughRG2D pixel shader")); + break; + case BLITSHADER_2D_RF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughR2D), + "Blit11 2D PassthroughR2D pixel shader")); + break; + case BLITSHADER_2D_ALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughA2D), + "Blit11 2D PassthroughA2D pixel shader")); + break; + case BLITSHADER_2D_LUMA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughLum2D), + "Blit11 2D PassthroughLum2D pixel shader")); + break; + case BLITSHADER_2D_LUMAALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughLumAlpha2D), + "Blit11 2D PassthroughLumAlpha2D pixel shader")); + break; + case BLITSHADER_2D_RGBAUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2DUI), + "Blit11 2D PassthroughRGBA2DUI pixel shader")); + break; + case BLITSHADER_2D_RGBAI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2DI), + "Blit11 2D PassthroughRGBA2DI pixel shader")); + break; + case BLITSHADER_2D_RGBUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGB2DUI), + "Blit11 2D PassthroughRGB2DUI pixel shader")); + break; + case BLITSHADER_2D_RGBI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGB2DI), + "Blit11 2D PassthroughRGB2DI pixel shader")); + break; + case BLITSHADER_2D_RGUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRG2DUI), + "Blit11 2D PassthroughRG2DUI pixel shader")); + break; + case BLITSHADER_2D_RGI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRG2DI), + "Blit11 2D PassthroughRG2DI pixel shader")); + break; + case BLITSHADER_2D_RUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughR2DUI), + "Blit11 2D PassthroughR2DUI pixel shader")); + break; + case BLITSHADER_2D_RI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughR2DI), + "Blit11 2D PassthroughR2DI pixel shader")); + break; + case BLITSHADER_2D_RGBAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_RGBA_2D), + "Blit11 2D FtoF PM RGBA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_RGBA_2D), + "Blit11 2D FtoF UM RGBA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_RGB_2D), + "Blit11 2D FtoF PM RGB 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_RGB_2D), + "Blit11 2D FtoF UM RGB 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_PT_RGBA_2D), + "Blit11 2D FtoU PT RGBA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_PM_RGBA_2D), + "Blit11 2D FtoU PM RGBA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_UM_RGBA_2D), + "Blit11 2D FtoU UM RGBA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_PT_RGB_2D), + "Blit11 2D FtoU PT RGB 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_PM_RGB_2D), + "Blit11 2D FtoU PM RGB 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoU_UM_RGB_2D), + "Blit11 2D FtoU UM RGB 2D pixel shader")); + break; + case BLITSHADER_2D_LUMAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_LUMA_2D), + "Blit11 2D FtoF PM LUMA 2D pixel shader")); + break; + case BLITSHADER_2D_LUMAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_LUMA_2D), + "Blit11 2D FtoF UM LUMA 2D pixel shader")); + break; + case BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_LUMAALPHA_2D), + "Blit11 2D FtoF PM LUMAALPHA 2D pixel shader")); + break; + case BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_LUMAALPHA_2D), + "Blit11 2D FtoF UM LUMAALPHA 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_4444: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2D_4444), + "Blit11 2D PassthroughRGBA2D 4444 pixel shader")); + break; + case BLITSHADER_2D_RGBAF_4444_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_RGBA_4444_2D), + "Blit11 2D FtoF PM RGBA 4444 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_4444_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_RGBA_4444_2D), + "Blit11 2D FtoF UM RGBA 4444 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_565: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGB2D_565), + "Blit11 2D PassthroughRGB2D 565 pixel shader")); + break; + case BLITSHADER_2D_RGBF_565_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_RGB_565_2D), + "Blit11 2D FtoF PM RGB 565 2D pixel shader")); + break; + case BLITSHADER_2D_RGBF_565_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_RGB_565_2D), + "Blit11 2D FtoF UM RGB 565 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_5551: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_PassthroughRGBA2D_5551), + "Blit11 2D PassthroughRGBA2D 5551 pixel shader")); + break; + case BLITSHADER_2D_RGBAF_5551_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_PM_RGBA_5551_2D), + "Blit11 2D FtoF PM RGBA 5551 2D pixel shader")); + break; + case BLITSHADER_2D_RGBAF_5551_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2D, + ShaderData(g_PS_FtoF_UM_RGBA_5551_2D), + "Blit11 2D FtoF UM RGBA 5551 2D pixel shader")); + break; + case BLITSHADER_3D_RGBAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3D), + "Blit11 3D PassthroughRGBA3D pixel shader")); + break; + case BLITSHADER_3D_BGRAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3D), + "Blit11 3D PassthroughRGBA3D pixel shader")); + break; + case BLITSHADER_3D_RGBF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGB3D), + "Blit11 3D PassthroughRGB3D pixel shader")); + break; + case BLITSHADER_3D_RGF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRG3D), + "Blit11 3D PassthroughRG3D pixel shader")); + break; + case BLITSHADER_3D_RF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughR3D), + "Blit11 3D PassthroughR3D pixel shader")); + break; + case BLITSHADER_3D_ALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3D), + "Blit11 3D PassthroughRGBA3D pixel shader")); + break; + case BLITSHADER_3D_LUMA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughLum3D), + "Blit11 3D PassthroughLum3D pixel shader")); + break; + case BLITSHADER_3D_LUMAALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughLumAlpha3D), + "Blit11 3D PassthroughLumAlpha3D pixel shader")); + break; + case BLITSHADER_3D_RGBAUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3DUI), + "Blit11 3D PassthroughRGBA3DUI pixel shader")); + break; + case BLITSHADER_3D_RGBAI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3DI), + "Blit11 3D PassthroughRGBA3DI pixel shader")); + break; + case BLITSHADER_3D_RGBUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGB3DUI), + "Blit11 3D PassthroughRGB3DUI pixel shader")); + break; + case BLITSHADER_3D_RGBI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGB3DI), + "Blit11 3D PassthroughRGB3DI pixel shader")); + break; + case BLITSHADER_3D_RGUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRG3DUI), + "Blit11 3D PassthroughRG3DUI pixel shader")); + break; + case BLITSHADER_3D_RGI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRG3DI), + "Blit11 3D PassthroughRG3DI pixel shader")); + break; + case BLITSHADER_3D_RUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughR3DUI), + "Blit11 3D PassthroughR3DUI pixel shader")); + break; + case BLITSHADER_3D_RI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughR3DI), + "Blit11 3D PassthroughR3DI pixel shader")); + break; + case BLITSHADER_3D_RGBAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_RGBA_3D), + "Blit11 3D FtoF PM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_RGBA_3D), + "Blit11 3D FtoF UM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_RGB_3D), + "Blit11 3D FtoF PM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_RGB_3D), + "Blit11 3D FtoF UM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_PT_RGBA_3D), + "Blit11 3D FtoU PT RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_PM_RGBA_3D), + "Blit11 3D FtoU PM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_UM_RGBA_3D), + "Blit11 3D FtoU UM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_PT_RGB_3D), + "Blit11 3D FtoU PT RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_PM_RGB_3D), + "Blit11 3D FtoU PM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoU_UM_RGB_3D), + "Blit11 3D FtoU UM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_PT_RGBA_3D), + "Blit11 3D FtoI PT RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_PM_RGBA_3D), + "Blit11 3D FtoI PM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_TOI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_UM_RGBA_3D), + "Blit11 3D FtoI UM RGBA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_PT_RGB_3D), + "Blit11 3D FtoI PT RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_PM_RGB_3D), + "Blit11 3D FtoI PM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_TOI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoI_UM_RGB_3D), + "Blit11 3D FtoI UM RGB 3D pixel shader")); + break; + case BLITSHADER_3D_LUMAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_LUMA_3D), + "Blit11 3D FtoF PM LUMA 3D pixel shader")); + break; + case BLITSHADER_3D_LUMAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_LUMA_3D), + "Blit11 3D FtoF UM LUMA 3D pixel shader")); + break; + case BLITSHADER_3D_LUMAALPHAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_LUMAALPHA_3D), + "Blit11 3D FtoF PM LUMAALPHA 3D pixel shader")); + break; + case BLITSHADER_3D_LUMAALPHAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_LUMAALPHA_3D), + "Blit11 3D FtoF UM LUMAALPHA 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_4444: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3D_4444), + "Blit11 3D PassthroughRGBA3D 4444 pixel shader")); + break; + case BLITSHADER_3D_RGBAF_4444_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_RGBA_4444_3D), + "Blit11 3D FtoF PM RGBA 4444 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_4444_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_RGBA_4444_3D), + "Blit11 3D FtoF UM RGBA 4444 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_565: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGB3D_565), + "Blit11 3D PassthroughRGB3D 565 pixel shader")); + break; + case BLITSHADER_3D_RGBF_565_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_RGB_565_3D), + "Blit11 3D FtoF PM RGB 565 3D pixel shader")); + break; + case BLITSHADER_3D_RGBF_565_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_RGB_565_3D), + "Blit11 3D FtoF UM RGB 565 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_5551: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_PassthroughRGBA3D_5551), + "Blit11 3D PassthroughRGBA3D 5551 pixel shader")); + break; + case BLITSHADER_3D_RGBAF_5551_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_PM_RGBA_5551_3D), + "Blit11 3D FtoF PM RGBA 5551 3D pixel shader")); + break; + case BLITSHADER_3D_RGBAF_5551_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_3D, + ShaderData(g_PS_FtoF_UM_RGBA_5551_3D), + "Blit11 3D FtoF UM RGBA 5551 3D pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArray), + "Blit11 2DArray PassthroughRGBA2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_BGRAF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArray), + "Blit11 2DArray PassthroughRGBA2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGB2DArray), + "Blit11 2DArray PassthroughRGB2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRG2DArray), + "Blit11 2DArray PassthroughRG2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RF: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughR2DArray), + "Blit11 2DArray PassthroughR2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_ALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArray), + "Blit11 2DArray PassthroughRGBA2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughLum2DArray), + "Blit11 2DArray PassthroughLum2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMAALPHA: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughLumAlpha2DArray), + "Blit11 2DArray PassthroughLumAlpha2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArrayUI), + "Blit11 2DArray PassthroughRGBA2DArrayUI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArrayI), + "Blit11 2DArray PassthroughRGBA2DArrayI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGB2DArrayUI), + "Blit11 2DArray PassthroughRGB2DArrayUI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGB2DArrayI), + "Blit11 2DArray PassthroughRGB2DArrayI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRG2DArrayUI), + "Blit11 2DArray PassthroughRG2DArrayUI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRG2DArrayI), + "Blit11 2DArray PassthroughRG2DArrayI pixel shader")); + break; + case BLITSHADER_2DARRAY_RUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughR2DArrayUI), + "Blit11 2DArray PassthroughR2DArrayUI pixel shader")); + break; + case BLITSHADER_2DARRAY_RI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughR2DArrayI), + "Blit11 2DArray PassthroughR2DArrayI pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_RGBA_2DArray), + "Blit11 2DArray FtoF PM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_RGBA_2DArray), + "Blit11 2DArray FtoF UM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_RGB_2DArray), + "Blit11 2DArray FtoF PM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_RGB_2DArray), + "Blit11 2DArray FtoF UM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_PT_RGBA_2DArray), + "Blit11 2DArray FtoU PT RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_PM_RGBA_2DArray), + "Blit11 2DArray FtoU PM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_UM_RGBA_2DArray), + "Blit11 2DArray FtoU UM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOUI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_PT_RGB_2DArray), + "Blit11 2DArray FtoU PT RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOUI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_PM_RGB_2DArray), + "Blit11 2DArray FtoU PM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOUI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoU_UM_RGB_2DArray), + "Blit11 2DArray FtoU UM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_PT_RGBA_2DArray), + "Blit11 2DArray FtoI PT RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_PM_RGBA_2DArray), + "Blit11 2DArray FtoI PM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_TOI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_UM_RGBA_2DArray), + "Blit11 2DArray FtoI UM RGBA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOI: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_PT_RGB_2DArray), + "Blit11 2DArray FtoI PT RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOI_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_PM_RGB_2DArray), + "Blit11 2DArray FtoI PM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_TOI_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoI_UM_RGB_2DArray), + "Blit11 2DArray FtoI UM RGB 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_LUMA_2DArray), + "Blit11 2DArray FtoF PM LUMA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_LUMA_2DArray), + "Blit11 2DArray FtoF UM LUMA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMAALPHAF_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_LUMAALPHA_2DArray), + "Blit11 2DArray FtoF PM LUMAALPHA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_LUMAALPHAF_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_LUMAALPHA_2DArray), + "Blit11 2DArray FtoF UM LUMAALPHA 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_4444: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArray_4444), + "Blit11 2DArray PassthroughRGBA2DArray 4444 pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_4444_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_RGBA_4444_2DArray), + "Blit11 2DArray FtoF PM RGBA 4444 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_4444_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_RGBA_4444_2DArray), + "Blit11 2DArray FtoF UM RGBA 4444 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_565: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGB2DArray_565), + "Blit11 2DArray PassthroughRGB2DArray 565 pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_565_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_RGB_565_2DArray), + "Blit11 2DArray FtoF PM RGB 565 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBF_565_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_RGB_565_2DArray), + "Blit11 2DArray FtoF UM RGB 565 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_5551: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_PassthroughRGBA2DArray_5551), + "Blit11 2DArray PassthroughRGBA2DArray 5551 pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_5551_PREMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_PM_RGBA_5551_2DArray), + "Blit11 2DArray FtoF PM RGBA 5551 2DArray pixel shader")); + break; + case BLITSHADER_2DARRAY_RGBAF_5551_UNMULTIPLY: + ANGLE_TRY(addBlitShaderToMap(context, blitShaderType, SHADER_2DARRAY, + ShaderData(g_PS_FtoF_UM_RGBA_5551_2DArray), + "Blit11 2DArray FtoF UM RGBA 5551 2DArray pixel shader")); + break; + default: + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + } + + return angle::Result::Continue; +} + diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp new file mode 100644 index 0000000000..8cc265f288 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp @@ -0,0 +1,1888 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Buffer11.cpp Defines the Buffer11 class. + +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" + +#include <memory> + +#include "common/MemoryBuffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/renderer_utils.h" + +namespace rx +{ + +namespace +{ + +template <typename T> +GLuint ReadIndexValueFromIndices(const uint8_t *data, size_t index) +{ + return reinterpret_cast<const T *>(data)[index]; +} +typedef GLuint (*ReadIndexValueFunction)(const uint8_t *data, size_t index); + +enum class CopyResult +{ + RECREATED, + NOT_RECREATED, +}; + +void CalculateConstantBufferParams(GLintptr offset, + GLsizeiptr size, + UINT *outFirstConstant, + UINT *outNumConstants) +{ + // The offset must be aligned to 256 bytes (should have been enforced by glBindBufferRange). + ASSERT(offset % 256 == 0); + + // firstConstant and numConstants are expressed in constants of 16-bytes. Furthermore they must + // be a multiple of 16 constants. + *outFirstConstant = static_cast<UINT>(offset / 16); + + // The GL size is not required to be aligned to a 256 bytes boundary. + // Round the size up to a 256 bytes boundary then express the results in constants of 16-bytes. + *outNumConstants = static_cast<UINT>(rx::roundUpPow2(size, static_cast<GLsizeiptr>(256)) / 16); + + // Since the size is rounded up, firstConstant + numConstants may be bigger than the actual size + // of the buffer. This behaviour is explictly allowed according to the documentation on + // ID3D11DeviceContext1::PSSetConstantBuffers1 + // https://msdn.microsoft.com/en-us/library/windows/desktop/hh404649%28v=vs.85%29.aspx +} + +} // anonymous namespace + +namespace gl_d3d11 +{ + +D3D11_MAP GetD3DMapTypeFromBits(BufferUsage usage, GLbitfield access) +{ + bool readBit = ((access & GL_MAP_READ_BIT) != 0); + bool writeBit = ((access & GL_MAP_WRITE_BIT) != 0); + + ASSERT(readBit || writeBit); + + // Note : we ignore the discard bit, because in D3D11, staging buffers + // don't accept the map-discard flag (discard only works for DYNAMIC usage) + + if (readBit && !writeBit) + { + return D3D11_MAP_READ; + } + else if (writeBit && !readBit) + { + // Special case for uniform storage - we only allow full buffer updates. + return usage == BUFFER_USAGE_UNIFORM || usage == BUFFER_USAGE_STRUCTURED + ? D3D11_MAP_WRITE_DISCARD + : D3D11_MAP_WRITE; + } + else if (writeBit && readBit) + { + return D3D11_MAP_READ_WRITE; + } + else + { + UNREACHABLE(); + return D3D11_MAP_READ; + } +} +} // namespace gl_d3d11 + +// Each instance of Buffer11::BufferStorage is specialized for a class of D3D binding points +// - vertex/transform feedback buffers +// - index buffers +// - pixel unpack buffers +// - uniform buffers +class Buffer11::BufferStorage : angle::NonCopyable +{ + public: + virtual ~BufferStorage() {} + + DataRevision getDataRevision() const { return mRevision; } + BufferUsage getUsage() const { return mUsage; } + size_t getSize() const { return mBufferSize; } + void setDataRevision(DataRevision rev) { mRevision = rev; } + + virtual bool isCPUAccessible(GLbitfield access) const = 0; + + virtual bool isGPUAccessible() const = 0; + + virtual angle::Result copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) = 0; + virtual angle::Result resize(const gl::Context *context, size_t size, bool preserveData) = 0; + + virtual angle::Result map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) = 0; + virtual void unmap() = 0; + + angle::Result setData(const gl::Context *context, + const uint8_t *data, + size_t offset, + size_t size); + + void setStructureByteStride(unsigned int structureByteStride); + + protected: + BufferStorage(Renderer11 *renderer, BufferUsage usage); + + Renderer11 *mRenderer; + DataRevision mRevision; + const BufferUsage mUsage; + size_t mBufferSize; +}; + +// A native buffer storage represents an underlying D3D11 buffer for a particular +// type of storage. +class Buffer11::NativeStorage : public Buffer11::BufferStorage +{ + public: + NativeStorage(Renderer11 *renderer, BufferUsage usage, const angle::Subject *onStorageChanged); + ~NativeStorage() override; + + bool isCPUAccessible(GLbitfield access) const override; + + bool isGPUAccessible() const override { return true; } + + const d3d11::Buffer &getBuffer() const { return mBuffer; } + angle::Result copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) override; + angle::Result resize(const gl::Context *context, size_t size, bool preserveData) override; + + angle::Result map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) override; + void unmap() override; + + angle::Result getSRVForFormat(const gl::Context *context, + DXGI_FORMAT srvFormat, + const d3d11::ShaderResourceView **srvOut); + angle::Result getRawUAV(const gl::Context *context, + unsigned int offset, + unsigned int size, + d3d11::UnorderedAccessView **uavOut); + + protected: + d3d11::Buffer mBuffer; + const angle::Subject *mOnStorageChanged; + + private: + static void FillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, + Renderer11 *renderer, + BufferUsage usage, + unsigned int bufferSize); + void clearSRVs(); + void clearUAVs(); + + std::map<DXGI_FORMAT, d3d11::ShaderResourceView> mBufferResourceViews; + std::map<std::pair<unsigned int, unsigned int>, d3d11::UnorderedAccessView> mBufferRawUAVs; +}; + +class Buffer11::StructuredBufferStorage : public Buffer11::NativeStorage +{ + public: + StructuredBufferStorage(Renderer11 *renderer, + BufferUsage usage, + const angle::Subject *onStorageChanged); + ~StructuredBufferStorage() override; + angle::Result resizeStructuredBuffer(const gl::Context *context, + unsigned int size, + unsigned int structureByteStride); + angle::Result getStructuredBufferRangeSRV(const gl::Context *context, + unsigned int offset, + unsigned int size, + unsigned int structureByteStride, + const d3d11::ShaderResourceView **bufferOut); + + private: + d3d11::ShaderResourceView mStructuredBufferResourceView; +}; + +// A emulated indexed buffer storage represents an underlying D3D11 buffer for data +// that has been expanded to match the indices list used. This storage is only +// used for FL9_3 pointsprite rendering emulation. +class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage +{ + public: + EmulatedIndexedStorage(Renderer11 *renderer); + ~EmulatedIndexedStorage() override; + + bool isCPUAccessible(GLbitfield access) const override { return true; } + + bool isGPUAccessible() const override { return false; } + + angle::Result getBuffer(const gl::Context *context, + SourceIndexData *indexInfo, + const TranslatedAttribute &attribute, + GLint startVertex, + const d3d11::Buffer **bufferOut); + + angle::Result copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) override; + + angle::Result resize(const gl::Context *context, size_t size, bool preserveData) override; + + angle::Result map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) override; + void unmap() override; + + private: + d3d11::Buffer mBuffer; // contains expanded data for use by D3D + angle::MemoryBuffer mMemoryBuffer; // original data (not expanded) + angle::MemoryBuffer mIndicesMemoryBuffer; // indices data +}; + +// Pack storage represents internal storage for pack buffers. We implement pack buffers +// as CPU memory, tied to a staging texture, for asynchronous texture readback. +class Buffer11::PackStorage : public Buffer11::BufferStorage +{ + public: + explicit PackStorage(Renderer11 *renderer); + ~PackStorage() override; + + bool isCPUAccessible(GLbitfield access) const override { return true; } + + bool isGPUAccessible() const override { return false; } + + angle::Result copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) override; + angle::Result resize(const gl::Context *context, size_t size, bool preserveData) override; + + angle::Result map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) override; + void unmap() override; + + angle::Result packPixels(const gl::Context *context, + const gl::FramebufferAttachment &readAttachment, + const PackPixelsParams ¶ms); + + private: + angle::Result flushQueuedPackCommand(const gl::Context *context); + + TextureHelper11 mStagingTexture; + angle::MemoryBuffer mMemoryBuffer; + std::unique_ptr<PackPixelsParams> mQueuedPackCommand; + PackPixelsParams mPackParams; + bool mDataModified; +}; + +// System memory storage stores a CPU memory buffer with our buffer data. +// For dynamic data, it's much faster to update the CPU memory buffer than +// it is to update a D3D staging buffer and read it back later. +class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage +{ + public: + explicit SystemMemoryStorage(Renderer11 *renderer); + ~SystemMemoryStorage() override {} + + bool isCPUAccessible(GLbitfield access) const override { return true; } + + bool isGPUAccessible() const override { return false; } + + angle::Result copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) override; + angle::Result resize(const gl::Context *context, size_t size, bool preserveData) override; + + angle::Result map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) override; + void unmap() override; + + angle::MemoryBuffer *getSystemCopy() { return &mSystemCopy; } + + protected: + angle::MemoryBuffer mSystemCopy; +}; + +Buffer11::Buffer11(const gl::BufferState &state, Renderer11 *renderer) + : BufferD3D(state, renderer), + mRenderer(renderer), + mSize(0), + mMappedStorage(nullptr), + mBufferStorages({}), + mLatestBufferStorage(nullptr), + mDeallocThresholds({}), + mIdleness({}), + mConstantBufferStorageAdditionalSize(0), + mMaxConstantBufferLruCount(0), + mStructuredBufferStorageAdditionalSize(0), + mMaxStructuredBufferLruCount(0) +{} + +Buffer11::~Buffer11() +{ + for (BufferStorage *&storage : mBufferStorages) + { + SafeDelete(storage); + } + + for (auto &p : mConstantBufferRangeStoragesCache) + { + SafeDelete(p.second.storage); + } + + for (auto &p : mStructuredBufferRangeStoragesCache) + { + SafeDelete(p.second.storage); + } + + mRenderer->onBufferDelete(this); +} + +angle::Result Buffer11::setData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + gl::BufferUsage usage) +{ + updateD3DBufferUsage(context, usage); + return setSubData(context, target, data, size, 0); +} + +angle::Result Buffer11::getData(const gl::Context *context, const uint8_t **outData) +{ + if (mSize == 0) + { + // TODO(http://anglebug.com/2840): This ensures that we don't crash or assert in robust + // buffer access behavior mode if there are buffers without any data. However, technically + // it should still be possible to draw, with fetches from this buffer returning zero. + return angle::Result::Stop; + } + + SystemMemoryStorage *systemMemoryStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_SYSTEM_MEMORY, &systemMemoryStorage)); + + ASSERT(systemMemoryStorage->getSize() >= mSize); + + *outData = systemMemoryStorage->getSystemCopy()->data(); + return angle::Result::Continue; +} + +angle::Result Buffer11::setSubData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + size_t offset) +{ + size_t requiredSize = size + offset; + + if (data && size > 0) + { + // Use system memory storage for dynamic buffers. + // Try using a constant storage for constant buffers + BufferStorage *writeBuffer = nullptr; + if (target == gl::BufferBinding::Uniform) + { + // If we are a very large uniform buffer, keep system memory storage around so that we + // aren't forced to read back from a constant buffer. We also check the workaround for + // Intel - this requires us to use system memory so we don't end up having to copy from + // a constant buffer to a staging buffer. + // TODO(jmadill): Use Context caps. + if (offset == 0 && size >= mSize && + size <= static_cast<UINT>(mRenderer->getNativeCaps().maxUniformBlockSize) && + !mRenderer->getFeatures().useSystemMemoryForConstantBuffers.enabled) + { + BufferStorage *latestStorage = nullptr; + ANGLE_TRY(getLatestBufferStorage(context, &latestStorage)); + if (latestStorage && (latestStorage->getUsage() == BUFFER_USAGE_STRUCTURED)) + { + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_STRUCTURED, &writeBuffer)); + } + else + { + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_UNIFORM, &writeBuffer)); + } + } + else + { + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_SYSTEM_MEMORY, &writeBuffer)); + } + } + else if (supportsDirectBinding()) + { + ANGLE_TRY(getStagingStorage(context, &writeBuffer)); + } + else + { + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_SYSTEM_MEMORY, &writeBuffer)); + } + + ASSERT(writeBuffer); + + // Explicitly resize the staging buffer, preserving data if the new data will not + // completely fill the buffer + if (writeBuffer->getSize() < requiredSize) + { + bool preserveData = (offset > 0); + ANGLE_TRY(writeBuffer->resize(context, requiredSize, preserveData)); + } + + ANGLE_TRY(writeBuffer->setData(context, static_cast<const uint8_t *>(data), offset, size)); + onStorageUpdate(writeBuffer); + } + + mSize = std::max(mSize, requiredSize); + invalidateStaticData(context); + + return angle::Result::Continue; +} + +angle::Result Buffer11::copySubData(const gl::Context *context, + BufferImpl *source, + GLintptr sourceOffset, + GLintptr destOffset, + GLsizeiptr size) +{ + Buffer11 *sourceBuffer = GetAs<Buffer11>(source); + ASSERT(sourceBuffer != nullptr); + + BufferStorage *copyDest = nullptr; + ANGLE_TRY(getLatestBufferStorage(context, ©Dest)); + + if (!copyDest) + { + ANGLE_TRY(getStagingStorage(context, ©Dest)); + } + + BufferStorage *copySource = nullptr; + ANGLE_TRY(sourceBuffer->getLatestBufferStorage(context, ©Source)); + + if (!copySource) + { + ANGLE_TRY(sourceBuffer->getStagingStorage(context, ©Source)); + } + + ASSERT(copySource && copyDest); + + // A staging buffer is needed if there is no cpu-cpu or gpu-gpu copy path avaiable. + if (!copyDest->isGPUAccessible() && !copySource->isCPUAccessible(GL_MAP_READ_BIT)) + { + ANGLE_TRY(sourceBuffer->getStagingStorage(context, ©Source)); + } + else if (!copySource->isGPUAccessible() && !copyDest->isCPUAccessible(GL_MAP_WRITE_BIT)) + { + ANGLE_TRY(getStagingStorage(context, ©Dest)); + } + + // D3D11 does not allow overlapped copies until 11.1, and only if the + // device supports D3D11_FEATURE_DATA_D3D11_OPTIONS::CopyWithOverlap + // Get around this via a different source buffer + if (copySource == copyDest) + { + if (copySource->getUsage() == BUFFER_USAGE_STAGING) + { + ANGLE_TRY( + getBufferStorage(context, BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK, ©Source)); + } + else + { + ANGLE_TRY(getStagingStorage(context, ©Source)); + } + } + + CopyResult copyResult = CopyResult::NOT_RECREATED; + ANGLE_TRY(copyDest->copyFromStorage(context, copySource, sourceOffset, size, destOffset, + ©Result)); + onStorageUpdate(copyDest); + + mSize = std::max<size_t>(mSize, destOffset + size); + invalidateStaticData(context); + + return angle::Result::Continue; +} + +angle::Result Buffer11::map(const gl::Context *context, GLenum access, void **mapPtr) +{ + // GL_OES_mapbuffer uses an enum instead of a bitfield for it's access, convert to a bitfield + // and call mapRange. + ASSERT(access == GL_WRITE_ONLY_OES); + return mapRange(context, 0, mSize, GL_MAP_WRITE_BIT, mapPtr); +} + +angle::Result Buffer11::mapRange(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + void **mapPtr) +{ + ASSERT(!mMappedStorage); + + BufferStorage *latestStorage = nullptr; + ANGLE_TRY(getLatestBufferStorage(context, &latestStorage)); + + if (latestStorage && (latestStorage->getUsage() == BUFFER_USAGE_PIXEL_PACK || + latestStorage->getUsage() == BUFFER_USAGE_STAGING)) + { + // Latest storage is mappable. + mMappedStorage = latestStorage; + } + else + { + // Fall back to using the staging buffer if the latest storage does not exist or is not + // CPU-accessible. + ANGLE_TRY(getStagingStorage(context, &mMappedStorage)); + } + + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_GL_ALLOC(context11, mMappedStorage); + + if ((access & GL_MAP_WRITE_BIT) > 0) + { + // Update the data revision immediately, since the data might be changed at any time + onStorageUpdate(mMappedStorage); + invalidateStaticData(context); + } + + uint8_t *mappedBuffer = nullptr; + ANGLE_TRY(mMappedStorage->map(context, offset, length, access, &mappedBuffer)); + ASSERT(mappedBuffer); + + *mapPtr = static_cast<void *>(mappedBuffer); + return angle::Result::Continue; +} + +angle::Result Buffer11::unmap(const gl::Context *context, GLboolean *result) +{ + ASSERT(mMappedStorage); + mMappedStorage->unmap(); + mMappedStorage = nullptr; + + // TODO: detect if we had corruption. if so, return false. + *result = GL_TRUE; + + return angle::Result::Continue; +} + +angle::Result Buffer11::markTransformFeedbackUsage(const gl::Context *context) +{ + ANGLE_TRY(markBufferUsage(context, BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK)); + return angle::Result::Continue; +} + +void Buffer11::updateDeallocThreshold(BufferUsage usage) +{ + // The following strategy was tuned on the Oort online benchmark (http://oortonline.gl/) + // as well as a custom microbenchmark (IndexConversionPerfTest.Run/index_range_d3d11) + + // First readback: 8 unmodified uses before we free buffer memory. + // After that, double the threshold each time until we reach the max. + if (mDeallocThresholds[usage] == 0) + { + mDeallocThresholds[usage] = 8; + } + else if (mDeallocThresholds[usage] < std::numeric_limits<unsigned int>::max() / 2u) + { + mDeallocThresholds[usage] *= 2u; + } + else + { + mDeallocThresholds[usage] = std::numeric_limits<unsigned int>::max(); + } +} + +// Free the storage if we decide it isn't being used very often. +angle::Result Buffer11::checkForDeallocation(const gl::Context *context, BufferUsage usage) +{ + mIdleness[usage]++; + + BufferStorage *&storage = mBufferStorages[usage]; + if (storage != nullptr && mIdleness[usage] > mDeallocThresholds[usage]) + { + BufferStorage *latestStorage = nullptr; + ANGLE_TRY(getLatestBufferStorage(context, &latestStorage)); + if (latestStorage != storage) + { + SafeDelete(storage); + } + } + + return angle::Result::Continue; +} + +// Keep system memory when we are using it for the canonical version of data. +bool Buffer11::canDeallocateSystemMemory() const +{ + // Must keep system memory on Intel. + if (mRenderer->getFeatures().useSystemMemoryForConstantBuffers.enabled) + { + return false; + } + + return (!mBufferStorages[BUFFER_USAGE_UNIFORM] || + mSize <= static_cast<size_t>(mRenderer->getNativeCaps().maxUniformBlockSize)); +} + +void Buffer11::markBufferUsage(BufferUsage usage) +{ + mIdleness[usage] = 0; +} + +angle::Result Buffer11::markBufferUsage(const gl::Context *context, BufferUsage usage) +{ + BufferStorage *bufferStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, usage, &bufferStorage)); + + if (bufferStorage) + { + onStorageUpdate(bufferStorage); + } + + invalidateStaticData(context); + return angle::Result::Continue; +} + +angle::Result Buffer11::garbageCollection(const gl::Context *context, BufferUsage currentUsage) +{ + if (currentUsage != BUFFER_USAGE_SYSTEM_MEMORY && canDeallocateSystemMemory()) + { + ANGLE_TRY(checkForDeallocation(context, BUFFER_USAGE_SYSTEM_MEMORY)); + } + + if (currentUsage != BUFFER_USAGE_STAGING) + { + ANGLE_TRY(checkForDeallocation(context, BUFFER_USAGE_STAGING)); + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::getBuffer(const gl::Context *context, + BufferUsage usage, + ID3D11Buffer **bufferOut) +{ + NativeStorage *storage = nullptr; + ANGLE_TRY(getBufferStorage(context, usage, &storage)); + *bufferOut = storage->getBuffer().get(); + return angle::Result::Continue; +} + +angle::Result Buffer11::getEmulatedIndexedBuffer(const gl::Context *context, + SourceIndexData *indexInfo, + const TranslatedAttribute &attribute, + GLint startVertex, + ID3D11Buffer **bufferOut) +{ + ASSERT(indexInfo); + + EmulatedIndexedStorage *emulatedStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_EMULATED_INDEXED_VERTEX, &emulatedStorage)); + + const d3d11::Buffer *nativeBuffer = nullptr; + ANGLE_TRY( + emulatedStorage->getBuffer(context, indexInfo, attribute, startVertex, &nativeBuffer)); + *bufferOut = nativeBuffer->get(); + return angle::Result::Continue; +} + +angle::Result Buffer11::getConstantBufferRange(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + const d3d11::Buffer **bufferOut, + UINT *firstConstantOut, + UINT *numConstantsOut) +{ + NativeStorage *bufferStorage = nullptr; + if ((offset == 0 && + size < static_cast<GLsizeiptr>(mRenderer->getNativeCaps().maxUniformBlockSize)) || + mRenderer->getRenderer11DeviceCaps().supportsConstantBufferOffsets) + { + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_UNIFORM, &bufferStorage)); + CalculateConstantBufferParams(offset, size, firstConstantOut, numConstantsOut); + } + else + { + ANGLE_TRY(getConstantBufferRangeStorage(context, offset, size, &bufferStorage)); + *firstConstantOut = 0; + *numConstantsOut = 0; + } + + *bufferOut = &bufferStorage->getBuffer(); + return angle::Result::Continue; +} + +angle::Result Buffer11::markRawBufferUsage(const gl::Context *context) +{ + ANGLE_TRY(markBufferUsage(context, BUFFER_USAGE_RAW_UAV)); + return angle::Result::Continue; +} + +angle::Result Buffer11::markTypedBufferUsage(const gl::Context *context) +{ + ANGLE_TRY(markBufferUsage(context, BUFFER_USAGE_TYPED_UAV)); + return angle::Result::Continue; +} + +angle::Result Buffer11::getRawUAVRange(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + d3d11::UnorderedAccessView **uavOut) +{ + NativeStorage *nativeStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_RAW_UAV, &nativeStorage)); + + return nativeStorage->getRawUAV(context, static_cast<unsigned int>(offset), + static_cast<unsigned int>(size), uavOut); +} + +angle::Result Buffer11::getSRV(const gl::Context *context, + DXGI_FORMAT srvFormat, + const d3d11::ShaderResourceView **srvOut) +{ + NativeStorage *nativeStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_PIXEL_UNPACK, &nativeStorage)); + return nativeStorage->getSRVForFormat(context, srvFormat, srvOut); +} + +angle::Result Buffer11::packPixels(const gl::Context *context, + const gl::FramebufferAttachment &readAttachment, + const PackPixelsParams ¶ms) +{ + PackStorage *packStorage = nullptr; + ANGLE_TRY(getBufferStorage(context, BUFFER_USAGE_PIXEL_PACK, &packStorage)); + + ASSERT(packStorage); + ANGLE_TRY(packStorage->packPixels(context, readAttachment, params)); + onStorageUpdate(packStorage); + + return angle::Result::Continue; +} + +size_t Buffer11::getTotalCPUBufferMemoryBytes() const +{ + size_t allocationSize = 0; + + BufferStorage *staging = mBufferStorages[BUFFER_USAGE_STAGING]; + allocationSize += staging ? staging->getSize() : 0; + + BufferStorage *sysMem = mBufferStorages[BUFFER_USAGE_SYSTEM_MEMORY]; + allocationSize += sysMem ? sysMem->getSize() : 0; + + return allocationSize; +} + +template <typename StorageOutT> +angle::Result Buffer11::getBufferStorage(const gl::Context *context, + BufferUsage usage, + StorageOutT **storageOut) +{ + ASSERT(0 <= usage && usage < BUFFER_USAGE_COUNT); + BufferStorage *&newStorage = mBufferStorages[usage]; + + if (!newStorage) + { + newStorage = allocateStorage(usage); + } + + markBufferUsage(usage); + + // resize buffer + if (newStorage->getSize() < mSize) + { + ANGLE_TRY(newStorage->resize(context, mSize, true)); + } + + ASSERT(newStorage); + + ANGLE_TRY(updateBufferStorage(context, newStorage, 0, mSize)); + ANGLE_TRY(garbageCollection(context, usage)); + + *storageOut = GetAs<StorageOutT>(newStorage); + return angle::Result::Continue; +} + +Buffer11::BufferStorage *Buffer11::allocateStorage(BufferUsage usage) +{ + updateDeallocThreshold(usage); + switch (usage) + { + case BUFFER_USAGE_PIXEL_PACK: + return new PackStorage(mRenderer); + case BUFFER_USAGE_SYSTEM_MEMORY: + return new SystemMemoryStorage(mRenderer); + case BUFFER_USAGE_EMULATED_INDEXED_VERTEX: + return new EmulatedIndexedStorage(mRenderer); + case BUFFER_USAGE_INDEX: + case BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK: + return new NativeStorage(mRenderer, usage, this); + case BUFFER_USAGE_STRUCTURED: + return new StructuredBufferStorage(mRenderer, usage, nullptr); + default: + return new NativeStorage(mRenderer, usage, nullptr); + } +} + +angle::Result Buffer11::getConstantBufferRangeStorage(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + Buffer11::NativeStorage **storageOut) +{ + BufferStorage *newStorage; + { + // Keep the cacheEntry in a limited scope because it may be invalidated later in the code if + // we need to reclaim some space. + BufferCacheEntry *cacheEntry = &mConstantBufferRangeStoragesCache[offset]; + + if (!cacheEntry->storage) + { + cacheEntry->storage = allocateStorage(BUFFER_USAGE_UNIFORM); + cacheEntry->lruCount = ++mMaxConstantBufferLruCount; + } + + cacheEntry->lruCount = ++mMaxConstantBufferLruCount; + newStorage = cacheEntry->storage; + } + + markBufferUsage(BUFFER_USAGE_UNIFORM); + + if (newStorage->getSize() < static_cast<size_t>(size)) + { + size_t maximumAllowedAdditionalSize = 2 * getSize(); + + size_t sizeDelta = size - newStorage->getSize(); + + while (mConstantBufferStorageAdditionalSize + sizeDelta > maximumAllowedAdditionalSize) + { + auto iter = std::min_element( + std::begin(mConstantBufferRangeStoragesCache), + std::end(mConstantBufferRangeStoragesCache), + [](const BufferCache::value_type &a, const BufferCache::value_type &b) { + return a.second.lruCount < b.second.lruCount; + }); + + ASSERT(iter->second.storage != newStorage); + ASSERT(mConstantBufferStorageAdditionalSize >= iter->second.storage->getSize()); + + mConstantBufferStorageAdditionalSize -= iter->second.storage->getSize(); + SafeDelete(iter->second.storage); + mConstantBufferRangeStoragesCache.erase(iter); + } + + ANGLE_TRY(newStorage->resize(context, size, false)); + mConstantBufferStorageAdditionalSize += sizeDelta; + + // We don't copy the old data when resizing the constant buffer because the data may be + // out-of-date therefore we reset the data revision and let updateBufferStorage() handle the + // copy. + newStorage->setDataRevision(0); + } + + ANGLE_TRY(updateBufferStorage(context, newStorage, offset, size)); + ANGLE_TRY(garbageCollection(context, BUFFER_USAGE_UNIFORM)); + *storageOut = GetAs<NativeStorage>(newStorage); + return angle::Result::Continue; +} + +angle::Result Buffer11::getStructuredBufferRangeSRV(const gl::Context *context, + unsigned int offset, + unsigned int size, + unsigned int structureByteStride, + const d3d11::ShaderResourceView **srvOut) +{ + BufferStorage *newStorage; + + { + // Keep the cacheEntry in a limited scope because it may be invalidated later in the code if + // we need to reclaim some space. + StructuredBufferKey structuredBufferKey = StructuredBufferKey(offset, structureByteStride); + BufferCacheEntry *cacheEntry = &mStructuredBufferRangeStoragesCache[structuredBufferKey]; + + if (!cacheEntry->storage) + { + cacheEntry->storage = allocateStorage(BUFFER_USAGE_STRUCTURED); + cacheEntry->lruCount = ++mMaxStructuredBufferLruCount; + } + + cacheEntry->lruCount = ++mMaxStructuredBufferLruCount; + newStorage = cacheEntry->storage; + } + + StructuredBufferStorage *structuredBufferStorage = GetAs<StructuredBufferStorage>(newStorage); + + markBufferUsage(BUFFER_USAGE_STRUCTURED); + + if (newStorage->getSize() < static_cast<size_t>(size)) + { + size_t maximumAllowedAdditionalSize = 2 * getSize(); + + size_t sizeDelta = static_cast<size_t>(size) - newStorage->getSize(); + + while (mStructuredBufferStorageAdditionalSize + sizeDelta > maximumAllowedAdditionalSize) + { + auto iter = std::min_element(std::begin(mStructuredBufferRangeStoragesCache), + std::end(mStructuredBufferRangeStoragesCache), + [](const StructuredBufferCache::value_type &a, + const StructuredBufferCache::value_type &b) { + return a.second.lruCount < b.second.lruCount; + }); + + ASSERT(iter->second.storage != newStorage); + ASSERT(mStructuredBufferStorageAdditionalSize >= iter->second.storage->getSize()); + + mStructuredBufferStorageAdditionalSize -= iter->second.storage->getSize(); + SafeDelete(iter->second.storage); + mStructuredBufferRangeStoragesCache.erase(iter); + } + + ANGLE_TRY( + structuredBufferStorage->resizeStructuredBuffer(context, size, structureByteStride)); + mStructuredBufferStorageAdditionalSize += sizeDelta; + + // We don't copy the old data when resizing the structured buffer because the data may be + // out-of-date therefore we reset the data revision and let updateBufferStorage() handle the + // copy. + newStorage->setDataRevision(0); + } + + ANGLE_TRY(updateBufferStorage(context, newStorage, offset, static_cast<size_t>(size))); + ANGLE_TRY(garbageCollection(context, BUFFER_USAGE_STRUCTURED)); + ANGLE_TRY(structuredBufferStorage->getStructuredBufferRangeSRV(context, offset, size, + structureByteStride, srvOut)); + return angle::Result::Continue; +} + +angle::Result Buffer11::updateBufferStorage(const gl::Context *context, + BufferStorage *storage, + size_t sourceOffset, + size_t storageSize) +{ + BufferStorage *latestBuffer = nullptr; + ANGLE_TRY(getLatestBufferStorage(context, &latestBuffer)); + + ASSERT(storage); + + if (!latestBuffer) + { + onStorageUpdate(storage); + return angle::Result::Continue; + } + + if (latestBuffer->getDataRevision() <= storage->getDataRevision()) + { + return angle::Result::Continue; + } + + if (latestBuffer->getSize() == 0 || storage->getSize() == 0) + { + return angle::Result::Continue; + } + + // Copy through a staging buffer if we're copying from or to a non-staging, mappable + // buffer storage. This is because we can't map a GPU buffer, and copy CPU + // data directly. If we're already using a staging buffer we're fine. + if (latestBuffer->getUsage() != BUFFER_USAGE_STAGING && + storage->getUsage() != BUFFER_USAGE_STAGING && + (!latestBuffer->isCPUAccessible(GL_MAP_READ_BIT) || + !storage->isCPUAccessible(GL_MAP_WRITE_BIT))) + { + NativeStorage *stagingBuffer = nullptr; + ANGLE_TRY(getStagingStorage(context, &stagingBuffer)); + + CopyResult copyResult = CopyResult::NOT_RECREATED; + ANGLE_TRY(stagingBuffer->copyFromStorage(context, latestBuffer, 0, latestBuffer->getSize(), + 0, ©Result)); + onCopyStorage(stagingBuffer, latestBuffer); + + latestBuffer = stagingBuffer; + } + + CopyResult copyResult = CopyResult::NOT_RECREATED; + ANGLE_TRY( + storage->copyFromStorage(context, latestBuffer, sourceOffset, storageSize, 0, ©Result)); + // If the D3D buffer has been recreated, we should update our serial. + if (copyResult == CopyResult::RECREATED) + { + updateSerial(); + } + onCopyStorage(storage, latestBuffer); + return angle::Result::Continue; +} + +angle::Result Buffer11::getLatestBufferStorage(const gl::Context *context, + Buffer11::BufferStorage **storageOut) const +{ + // resize buffer + if (mLatestBufferStorage && mLatestBufferStorage->getSize() < mSize) + { + ANGLE_TRY(mLatestBufferStorage->resize(context, mSize, true)); + } + + *storageOut = mLatestBufferStorage; + return angle::Result::Continue; +} + +template <typename StorageOutT> +angle::Result Buffer11::getStagingStorage(const gl::Context *context, StorageOutT **storageOut) +{ + return getBufferStorage(context, BUFFER_USAGE_STAGING, storageOut); +} + +size_t Buffer11::getSize() const +{ + return mSize; +} + +bool Buffer11::supportsDirectBinding() const +{ + // Do not support direct buffers for dynamic data. The streaming buffer + // offers better performance for data which changes every frame. + return (mUsage == D3DBufferUsage::STATIC); +} + +void Buffer11::initializeStaticData(const gl::Context *context) +{ + BufferD3D::initializeStaticData(context); + onStateChange(angle::SubjectMessage::SubjectChanged); +} + +void Buffer11::invalidateStaticData(const gl::Context *context) +{ + BufferD3D::invalidateStaticData(context); + onStateChange(angle::SubjectMessage::SubjectChanged); +} + +void Buffer11::onCopyStorage(BufferStorage *dest, BufferStorage *source) +{ + ASSERT(source && mLatestBufferStorage); + dest->setDataRevision(source->getDataRevision()); + + // Only update the latest buffer storage if our usage index is lower. See comment in header. + if (dest->getUsage() < mLatestBufferStorage->getUsage()) + { + mLatestBufferStorage = dest; + } +} + +void Buffer11::onStorageUpdate(BufferStorage *updatedStorage) +{ + updatedStorage->setDataRevision(updatedStorage->getDataRevision() + 1); + mLatestBufferStorage = updatedStorage; +} + +// Buffer11::BufferStorage implementation + +Buffer11::BufferStorage::BufferStorage(Renderer11 *renderer, BufferUsage usage) + : mRenderer(renderer), mRevision(0), mUsage(usage), mBufferSize(0) +{} + +angle::Result Buffer11::BufferStorage::setData(const gl::Context *context, + const uint8_t *data, + size_t offset, + size_t size) +{ + ASSERT(isCPUAccessible(GL_MAP_WRITE_BIT)); + + // Uniform storage can have a different internal size than the buffer size. Ensure we don't + // overflow. + size_t mapSize = std::min(size, mBufferSize - offset); + + uint8_t *writePointer = nullptr; + ANGLE_TRY(map(context, offset, mapSize, GL_MAP_WRITE_BIT, &writePointer)); + + memcpy(writePointer, data, mapSize); + + unmap(); + + return angle::Result::Continue; +} + +// Buffer11::NativeStorage implementation + +Buffer11::NativeStorage::NativeStorage(Renderer11 *renderer, + BufferUsage usage, + const angle::Subject *onStorageChanged) + : BufferStorage(renderer, usage), mBuffer(), mOnStorageChanged(onStorageChanged) +{} + +Buffer11::NativeStorage::~NativeStorage() +{ + clearSRVs(); + clearUAVs(); +} + +bool Buffer11::NativeStorage::isCPUAccessible(GLbitfield access) const +{ + if ((access & GL_MAP_READ_BIT) != 0) + { + // Read is more exclusive than write mappability. + return (mUsage == BUFFER_USAGE_STAGING); + } + ASSERT((access & GL_MAP_WRITE_BIT) != 0); + return (mUsage == BUFFER_USAGE_STAGING || mUsage == BUFFER_USAGE_UNIFORM || + mUsage == BUFFER_USAGE_STRUCTURED); +} + +// Returns true if it recreates the direct buffer +angle::Result Buffer11::NativeStorage::copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) +{ + size_t requiredSize = destOffset + size; + + // (Re)initialize D3D buffer if needed + bool preserveData = (destOffset > 0); + if (!mBuffer.valid() || mBufferSize < requiredSize) + { + ANGLE_TRY(resize(context, requiredSize, preserveData)); + *resultOut = CopyResult::RECREATED; + } + else + { + *resultOut = CopyResult::NOT_RECREATED; + } + + size_t clampedSize = size; + if (mUsage == BUFFER_USAGE_UNIFORM) + { + clampedSize = std::min(clampedSize, mBufferSize - destOffset); + } + + if (clampedSize == 0) + { + return angle::Result::Continue; + } + + if (source->getUsage() == BUFFER_USAGE_PIXEL_PACK || + source->getUsage() == BUFFER_USAGE_SYSTEM_MEMORY) + { + ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT) && isCPUAccessible(GL_MAP_WRITE_BIT)); + + // Uniform buffers must be mapped with write/discard. + ASSERT(!(preserveData && mUsage == BUFFER_USAGE_UNIFORM)); + + uint8_t *sourcePointer = nullptr; + ANGLE_TRY(source->map(context, sourceOffset, clampedSize, GL_MAP_READ_BIT, &sourcePointer)); + + auto err = setData(context, sourcePointer, destOffset, clampedSize); + source->unmap(); + ANGLE_TRY(err); + } + else + { + D3D11_BOX srcBox; + srcBox.left = static_cast<unsigned int>(sourceOffset); + srcBox.right = static_cast<unsigned int>(sourceOffset + clampedSize); + srcBox.top = 0; + srcBox.bottom = 1; + srcBox.front = 0; + srcBox.back = 1; + + const d3d11::Buffer *sourceBuffer = &GetAs<NativeStorage>(source)->getBuffer(); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->CopySubresourceRegion(mBuffer.get(), 0, + static_cast<unsigned int>(destOffset), 0, 0, + sourceBuffer->get(), 0, &srcBox); + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::NativeStorage::resize(const gl::Context *context, + size_t size, + bool preserveData) +{ + if (size == 0) + { + mBuffer.reset(); + mBufferSize = 0; + return angle::Result::Continue; + } + + D3D11_BUFFER_DESC bufferDesc; + FillBufferDesc(&bufferDesc, mRenderer, mUsage, static_cast<unsigned int>(size)); + + d3d11::Buffer newBuffer; + ANGLE_TRY( + mRenderer->allocateResource(SafeGetImplAs<Context11>(context), bufferDesc, &newBuffer)); + newBuffer.setInternalName("Buffer11::NativeStorage"); + + if (mBuffer.valid() && preserveData) + { + // We don't call resize if the buffer is big enough already. + ASSERT(mBufferSize <= size); + + D3D11_BOX srcBox; + srcBox.left = 0; + srcBox.right = static_cast<unsigned int>(mBufferSize); + srcBox.top = 0; + srcBox.bottom = 1; + srcBox.front = 0; + srcBox.back = 1; + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->CopySubresourceRegion(newBuffer.get(), 0, 0, 0, 0, mBuffer.get(), 0, + &srcBox); + } + + // No longer need the old buffer + mBuffer = std::move(newBuffer); + + mBufferSize = bufferDesc.ByteWidth; + + // Free the SRVs. + clearSRVs(); + + // Free the UAVs. + clearUAVs(); + + // Notify that the storage has changed. + if (mOnStorageChanged) + { + mOnStorageChanged->onStateChange(angle::SubjectMessage::SubjectChanged); + } + + return angle::Result::Continue; +} + +// static +void Buffer11::NativeStorage::FillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, + Renderer11 *renderer, + BufferUsage usage, + unsigned int bufferSize) +{ + bufferDesc->ByteWidth = bufferSize; + bufferDesc->MiscFlags = 0; + bufferDesc->StructureByteStride = 0; + + switch (usage) + { + case BUFFER_USAGE_STAGING: + bufferDesc->Usage = D3D11_USAGE_STAGING; + bufferDesc->BindFlags = 0; + bufferDesc->CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + break; + + case BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK: + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->BindFlags = D3D11_BIND_VERTEX_BUFFER; + + if (renderer->isES3Capable()) + { + bufferDesc->BindFlags |= D3D11_BIND_STREAM_OUTPUT; + } + + bufferDesc->CPUAccessFlags = 0; + break; + + case BUFFER_USAGE_INDEX: + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->BindFlags = D3D11_BIND_INDEX_BUFFER; + bufferDesc->CPUAccessFlags = 0; + break; + + case BUFFER_USAGE_INDIRECT: + bufferDesc->MiscFlags = D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS; + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->BindFlags = 0; + bufferDesc->CPUAccessFlags = 0; + break; + + case BUFFER_USAGE_PIXEL_UNPACK: + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->BindFlags = D3D11_BIND_SHADER_RESOURCE; + bufferDesc->CPUAccessFlags = 0; + break; + + case BUFFER_USAGE_UNIFORM: + bufferDesc->Usage = D3D11_USAGE_DYNAMIC; + bufferDesc->BindFlags = D3D11_BIND_CONSTANT_BUFFER; + bufferDesc->CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + + // Constant buffers must be of a limited size, and aligned to 16 byte boundaries + // For our purposes we ignore any buffer data past the maximum constant buffer size + bufferDesc->ByteWidth = roundUpPow2(bufferDesc->ByteWidth, 16u); + + // Note: it seems that D3D11 allows larger buffers on some platforms, but not all. + // (Windows 10 seems to allow larger constant buffers, but not Windows 7) + if (!renderer->getRenderer11DeviceCaps().supportsConstantBufferOffsets) + { + bufferDesc->ByteWidth = std::min<UINT>( + bufferDesc->ByteWidth, + static_cast<UINT>(renderer->getNativeCaps().maxUniformBlockSize)); + } + break; + + case BUFFER_USAGE_RAW_UAV: + bufferDesc->MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bufferDesc->BindFlags = D3D11_BIND_UNORDERED_ACCESS; + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->CPUAccessFlags = 0; + break; + case BUFFER_USAGE_TYPED_UAV: + bufferDesc->BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; + bufferDesc->Usage = D3D11_USAGE_DEFAULT; + bufferDesc->CPUAccessFlags = 0; + bufferDesc->MiscFlags = 0; + break; + + default: + UNREACHABLE(); + } +} + +angle::Result Buffer11::NativeStorage::map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) +{ + ASSERT(isCPUAccessible(access)); + + D3D11_MAPPED_SUBRESOURCE mappedResource; + D3D11_MAP d3dMapType = gl_d3d11::GetD3DMapTypeFromBits(mUsage, access); + UINT d3dMapFlag = ((access & GL_MAP_UNSYNCHRONIZED_BIT) != 0 ? D3D11_MAP_FLAG_DO_NOT_WAIT : 0); + + ANGLE_TRY( + mRenderer->mapResource(context, mBuffer.get(), 0, d3dMapType, d3dMapFlag, &mappedResource)); + ASSERT(mappedResource.pData); + *mapPointerOut = static_cast<uint8_t *>(mappedResource.pData) + offset; + return angle::Result::Continue; +} + +void Buffer11::NativeStorage::unmap() +{ + ASSERT(isCPUAccessible(GL_MAP_WRITE_BIT) || isCPUAccessible(GL_MAP_READ_BIT)); + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + context->Unmap(mBuffer.get(), 0); +} + +angle::Result Buffer11::NativeStorage::getSRVForFormat(const gl::Context *context, + DXGI_FORMAT srvFormat, + const d3d11::ShaderResourceView **srvOut) +{ + auto bufferSRVIt = mBufferResourceViews.find(srvFormat); + + if (bufferSRVIt != mBufferResourceViews.end()) + { + *srvOut = &bufferSRVIt->second; + return angle::Result::Continue; + } + + const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(srvFormat); + + D3D11_SHADER_RESOURCE_VIEW_DESC bufferSRVDesc; + bufferSRVDesc.Buffer.ElementOffset = 0; + bufferSRVDesc.Buffer.ElementWidth = static_cast<UINT>(mBufferSize) / dxgiFormatInfo.pixelBytes; + bufferSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + bufferSRVDesc.Format = srvFormat; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferSRVDesc, + mBuffer.get(), &mBufferResourceViews[srvFormat])); + + *srvOut = &mBufferResourceViews[srvFormat]; + return angle::Result::Continue; +} + +angle::Result Buffer11::NativeStorage::getRawUAV(const gl::Context *context, + unsigned int offset, + unsigned int size, + d3d11::UnorderedAccessView **uavOut) +{ + ASSERT(offset + size <= mBufferSize); + + auto bufferRawUAV = mBufferRawUAVs.find({offset, size}); + if (bufferRawUAV != mBufferRawUAVs.end()) + { + *uavOut = &bufferRawUAV->second; + return angle::Result::Continue; + } + + D3D11_UNORDERED_ACCESS_VIEW_DESC bufferUAVDesc; + + // DXGI_FORMAT_R32_TYPELESS uses 4 bytes per element + constexpr int kBytesToElement = 4; + bufferUAVDesc.Buffer.FirstElement = offset / kBytesToElement; + bufferUAVDesc.Buffer.NumElements = size / kBytesToElement; + bufferUAVDesc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW; + bufferUAVDesc.Format = DXGI_FORMAT_R32_TYPELESS; // Format must be DXGI_FORMAT_R32_TYPELESS, + // when creating Raw Unordered Access View + bufferUAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferUAVDesc, + mBuffer.get(), &mBufferRawUAVs[{offset, size}])); + *uavOut = &mBufferRawUAVs[{offset, size}]; + return angle::Result::Continue; +} + +void Buffer11::NativeStorage::clearSRVs() +{ + mBufferResourceViews.clear(); +} + +void Buffer11::NativeStorage::clearUAVs() +{ + mBufferRawUAVs.clear(); +} + +Buffer11::StructuredBufferStorage::StructuredBufferStorage(Renderer11 *renderer, + BufferUsage usage, + const angle::Subject *onStorageChanged) + : NativeStorage(renderer, usage, onStorageChanged), mStructuredBufferResourceView() +{} + +Buffer11::StructuredBufferStorage::~StructuredBufferStorage() +{ + mStructuredBufferResourceView.reset(); +} + +angle::Result Buffer11::StructuredBufferStorage::resizeStructuredBuffer( + const gl::Context *context, + unsigned int size, + unsigned int structureByteStride) +{ + if (size == 0) + { + mBuffer.reset(); + mBufferSize = 0; + return angle::Result::Continue; + } + + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = size; + bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; + bufferDesc.StructureByteStride = structureByteStride; + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + bufferDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + + d3d11::Buffer newBuffer; + ANGLE_TRY( + mRenderer->allocateResource(SafeGetImplAs<Context11>(context), bufferDesc, &newBuffer)); + newBuffer.setInternalName("Buffer11::StructuredBufferStorage"); + + // No longer need the old buffer + mBuffer = std::move(newBuffer); + + mBufferSize = static_cast<size_t>(bufferDesc.ByteWidth); + + mStructuredBufferResourceView.reset(); + + // Notify that the storage has changed. + if (mOnStorageChanged) + { + mOnStorageChanged->onStateChange(angle::SubjectMessage::SubjectChanged); + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::StructuredBufferStorage::getStructuredBufferRangeSRV( + const gl::Context *context, + unsigned int offset, + unsigned int size, + unsigned int structureByteStride, + const d3d11::ShaderResourceView **srvOut) +{ + if (mStructuredBufferResourceView.valid()) + { + *srvOut = &mStructuredBufferResourceView; + return angle::Result::Continue; + } + + D3D11_SHADER_RESOURCE_VIEW_DESC bufferSRVDesc = {}; + bufferSRVDesc.BufferEx.NumElements = structureByteStride == 0u ? 1 : size / structureByteStride; + bufferSRVDesc.BufferEx.FirstElement = 0; + bufferSRVDesc.BufferEx.Flags = 0; + bufferSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; + bufferSRVDesc.Format = DXGI_FORMAT_UNKNOWN; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferSRVDesc, + mBuffer.get(), &mStructuredBufferResourceView)); + + *srvOut = &mStructuredBufferResourceView; + return angle::Result::Continue; +} + +// Buffer11::EmulatedIndexStorage implementation +Buffer11::EmulatedIndexedStorage::EmulatedIndexedStorage(Renderer11 *renderer) + : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX), mBuffer() +{} + +Buffer11::EmulatedIndexedStorage::~EmulatedIndexedStorage() {} + +angle::Result Buffer11::EmulatedIndexedStorage::getBuffer(const gl::Context *context, + SourceIndexData *indexInfo, + const TranslatedAttribute &attribute, + GLint startVertex, + const d3d11::Buffer **bufferOut) +{ + Context11 *context11 = GetImplAs<Context11>(context); + + // If a change in the indices applied from the last draw call is detected, then the emulated + // indexed buffer needs to be invalidated. After invalidation, the change detected flag should + // be cleared to avoid unnecessary recreation of the buffer. + if (!mBuffer.valid() || indexInfo->srcIndicesChanged) + { + mBuffer.reset(); + + // Copy the source index data. This ensures that the lifetime of the indices pointer + // stays with this storage until the next time we invalidate. + size_t indicesDataSize = 0; + switch (indexInfo->srcIndexType) + { + case gl::DrawElementsType::UnsignedInt: + indicesDataSize = sizeof(GLuint) * indexInfo->srcCount; + break; + case gl::DrawElementsType::UnsignedShort: + indicesDataSize = sizeof(GLushort) * indexInfo->srcCount; + break; + case gl::DrawElementsType::UnsignedByte: + indicesDataSize = sizeof(GLubyte) * indexInfo->srcCount; + break; + default: + indicesDataSize = sizeof(GLushort) * indexInfo->srcCount; + break; + } + + ANGLE_CHECK_GL_ALLOC(context11, mIndicesMemoryBuffer.resize(indicesDataSize)); + + memcpy(mIndicesMemoryBuffer.data(), indexInfo->srcIndices, indicesDataSize); + + indexInfo->srcIndicesChanged = false; + } + + if (!mBuffer.valid()) + { + unsigned int offset = 0; + ANGLE_TRY(attribute.computeOffset(context, startVertex, &offset)); + + // Expand the memory storage upon request and cache the results. + unsigned int expandedDataSize = + static_cast<unsigned int>((indexInfo->srcCount * attribute.stride) + offset); + angle::MemoryBuffer expandedData; + ANGLE_CHECK_GL_ALLOC(context11, expandedData.resize(expandedDataSize)); + + // Clear the contents of the allocated buffer + ZeroMemory(expandedData.data(), expandedDataSize); + + uint8_t *curr = expandedData.data(); + const uint8_t *ptr = static_cast<const uint8_t *>(indexInfo->srcIndices); + + // Ensure that we start in the correct place for the emulated data copy operation to + // maintain offset behaviors. + curr += offset; + + ReadIndexValueFunction readIndexValue = ReadIndexValueFromIndices<GLushort>; + + switch (indexInfo->srcIndexType) + { + case gl::DrawElementsType::UnsignedInt: + readIndexValue = ReadIndexValueFromIndices<GLuint>; + break; + case gl::DrawElementsType::UnsignedShort: + readIndexValue = ReadIndexValueFromIndices<GLushort>; + break; + case gl::DrawElementsType::UnsignedByte: + readIndexValue = ReadIndexValueFromIndices<GLubyte>; + break; + default: + UNREACHABLE(); + return angle::Result::Stop; + } + + // Iterate over the cached index data and copy entries indicated into the emulated buffer. + for (GLuint i = 0; i < indexInfo->srcCount; i++) + { + GLuint idx = readIndexValue(ptr, i); + memcpy(curr, mMemoryBuffer.data() + (attribute.stride * idx), attribute.stride); + curr += attribute.stride; + } + + // Finally, initialize the emulated indexed native storage object with the newly copied data + // and free the temporary buffers used. + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = expandedDataSize; + bufferDesc.MiscFlags = 0; + bufferDesc.StructureByteStride = 0; + bufferDesc.Usage = D3D11_USAGE_DEFAULT; + bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + bufferDesc.CPUAccessFlags = 0; + + D3D11_SUBRESOURCE_DATA subResourceData = {expandedData.data(), 0, 0}; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, + &subResourceData, &mBuffer)); + mBuffer.setInternalName("Buffer11::EmulatedIndexedStorage"); + } + + *bufferOut = &mBuffer; + return angle::Result::Continue; +} + +angle::Result Buffer11::EmulatedIndexedStorage::copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) +{ + ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT)); + uint8_t *sourceData = nullptr; + ANGLE_TRY(source->map(context, sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); + ASSERT(destOffset + size <= mMemoryBuffer.size()); + memcpy(mMemoryBuffer.data() + destOffset, sourceData, size); + source->unmap(); + *resultOut = CopyResult::RECREATED; + return angle::Result::Continue; +} + +angle::Result Buffer11::EmulatedIndexedStorage::resize(const gl::Context *context, + size_t size, + bool preserveData) +{ + if (mMemoryBuffer.size() < size) + { + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_GL_ALLOC(context11, mMemoryBuffer.resize(size)); + mBufferSize = size; + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::EmulatedIndexedStorage::map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) +{ + ASSERT(!mMemoryBuffer.empty() && offset + length <= mMemoryBuffer.size()); + *mapPointerOut = mMemoryBuffer.data() + offset; + return angle::Result::Continue; +} + +void Buffer11::EmulatedIndexedStorage::unmap() +{ + // No-op +} + +// Buffer11::PackStorage implementation + +Buffer11::PackStorage::PackStorage(Renderer11 *renderer) + : BufferStorage(renderer, BUFFER_USAGE_PIXEL_PACK), mStagingTexture(), mDataModified(false) +{} + +Buffer11::PackStorage::~PackStorage() {} + +angle::Result Buffer11::PackStorage::copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) +{ + ANGLE_TRY(flushQueuedPackCommand(context)); + + // For all use cases of pack buffers, we must copy through a readable buffer. + ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT)); + uint8_t *sourceData = nullptr; + ANGLE_TRY(source->map(context, sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); + ASSERT(destOffset + size <= mMemoryBuffer.size()); + memcpy(mMemoryBuffer.data() + destOffset, sourceData, size); + source->unmap(); + *resultOut = CopyResult::NOT_RECREATED; + return angle::Result::Continue; +} + +angle::Result Buffer11::PackStorage::resize(const gl::Context *context, + size_t size, + bool preserveData) +{ + if (size != mBufferSize) + { + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_GL_ALLOC(context11, mMemoryBuffer.resize(size)); + mBufferSize = size; + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::PackStorage::map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) +{ + ASSERT(offset + length <= getSize()); + // TODO: fast path + // We might be able to optimize out one or more memcpy calls by detecting when + // and if D3D packs the staging texture memory identically to how we would fill + // the pack buffer according to the current pack state. + + ANGLE_TRY(flushQueuedPackCommand(context)); + + mDataModified = (mDataModified || (access & GL_MAP_WRITE_BIT) != 0); + + *mapPointerOut = mMemoryBuffer.data() + offset; + return angle::Result::Continue; +} + +void Buffer11::PackStorage::unmap() +{ + // No-op +} + +angle::Result Buffer11::PackStorage::packPixels(const gl::Context *context, + const gl::FramebufferAttachment &readAttachment, + const PackPixelsParams ¶ms) +{ + ANGLE_TRY(flushQueuedPackCommand(context)); + + RenderTarget11 *renderTarget = nullptr; + ANGLE_TRY(readAttachment.getRenderTarget(context, 0, &renderTarget)); + + const TextureHelper11 &srcTexture = renderTarget->getTexture(); + ASSERT(srcTexture.valid()); + unsigned int srcSubresource = renderTarget->getSubresourceIndex(); + + mQueuedPackCommand.reset(new PackPixelsParams(params)); + + gl::Extents srcTextureSize(params.area.width, params.area.height, 1); + if (!mStagingTexture.get() || mStagingTexture.getFormat() != srcTexture.getFormat() || + mStagingTexture.getExtents() != srcTextureSize) + { + ANGLE_TRY(mRenderer->createStagingTexture(context, srcTexture.getTextureType(), + srcTexture.getFormatSet(), srcTextureSize, + StagingAccess::READ, &mStagingTexture)); + } + + // ReadPixels from multisampled FBOs isn't supported in current GL + ASSERT(srcTexture.getSampleCount() <= 1); + + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + D3D11_BOX srcBox; + srcBox.left = params.area.x; + srcBox.right = params.area.x + params.area.width; + srcBox.top = params.area.y; + srcBox.bottom = params.area.y + params.area.height; + + // Select the correct layer from a 3D attachment + srcBox.front = 0; + if (mStagingTexture.is3D()) + { + srcBox.front = static_cast<UINT>(readAttachment.layer()); + } + srcBox.back = srcBox.front + 1; + + // Asynchronous copy + immediateContext->CopySubresourceRegion(mStagingTexture.get(), 0, 0, 0, 0, srcTexture.get(), + srcSubresource, &srcBox); + + return angle::Result::Continue; +} + +angle::Result Buffer11::PackStorage::flushQueuedPackCommand(const gl::Context *context) +{ + ASSERT(mMemoryBuffer.size() > 0); + + if (mQueuedPackCommand) + { + ANGLE_TRY(mRenderer->packPixels(context, mStagingTexture, *mQueuedPackCommand, + mMemoryBuffer.data())); + mQueuedPackCommand.reset(nullptr); + } + + return angle::Result::Continue; +} + +// Buffer11::SystemMemoryStorage implementation + +Buffer11::SystemMemoryStorage::SystemMemoryStorage(Renderer11 *renderer) + : Buffer11::BufferStorage(renderer, BUFFER_USAGE_SYSTEM_MEMORY) +{} + +angle::Result Buffer11::SystemMemoryStorage::copyFromStorage(const gl::Context *context, + BufferStorage *source, + size_t sourceOffset, + size_t size, + size_t destOffset, + CopyResult *resultOut) +{ + ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT)); + uint8_t *sourceData = nullptr; + ANGLE_TRY(source->map(context, sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); + ASSERT(destOffset + size <= mSystemCopy.size()); + memcpy(mSystemCopy.data() + destOffset, sourceData, size); + source->unmap(); + *resultOut = CopyResult::RECREATED; + return angle::Result::Continue; +} + +angle::Result Buffer11::SystemMemoryStorage::resize(const gl::Context *context, + size_t size, + bool preserveData) +{ + if (mSystemCopy.size() < size) + { + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_GL_ALLOC(context11, mSystemCopy.resize(size)); + mBufferSize = size; + } + + return angle::Result::Continue; +} + +angle::Result Buffer11::SystemMemoryStorage::map(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + uint8_t **mapPointerOut) +{ + ASSERT(!mSystemCopy.empty() && offset + length <= mSystemCopy.size()); + *mapPointerOut = mSystemCopy.data() + offset; + return angle::Result::Continue; +} + +void Buffer11::SystemMemoryStorage::unmap() +{ + // No-op +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.h new file mode 100644 index 0000000000..b24bd1a48b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Buffer11.h @@ -0,0 +1,234 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Buffer11.h: Defines the rx::Buffer11 class which implements rx::BufferImpl via rx::BufferD3D. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_ + +#include <array> +#include <map> + +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace gl +{ +class FramebufferAttachment; +} + +namespace rx +{ +struct PackPixelsParams; +class Renderer11; +struct SourceIndexData; +struct TranslatedAttribute; + +// The order of this enum governs priority of 'getLatestBufferStorage'. +enum BufferUsage +{ + BUFFER_USAGE_SYSTEM_MEMORY, + BUFFER_USAGE_STAGING, + BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK, + BUFFER_USAGE_INDEX, + BUFFER_USAGE_INDIRECT, + BUFFER_USAGE_PIXEL_UNPACK, + BUFFER_USAGE_PIXEL_PACK, + BUFFER_USAGE_UNIFORM, + BUFFER_USAGE_STRUCTURED, + BUFFER_USAGE_EMULATED_INDEXED_VERTEX, + BUFFER_USAGE_RAW_UAV, + BUFFER_USAGE_TYPED_UAV, + + BUFFER_USAGE_COUNT, +}; + +typedef size_t DataRevision; + +class Buffer11 : public BufferD3D +{ + public: + Buffer11(const gl::BufferState &state, Renderer11 *renderer); + ~Buffer11() override; + + angle::Result getBuffer(const gl::Context *context, + BufferUsage usage, + ID3D11Buffer **bufferOut); + angle::Result getEmulatedIndexedBuffer(const gl::Context *context, + SourceIndexData *indexInfo, + const TranslatedAttribute &attribute, + GLint startVertex, + ID3D11Buffer **bufferOut); + angle::Result getConstantBufferRange(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + const d3d11::Buffer **bufferOut, + UINT *firstConstantOut, + UINT *numConstantsOut); + angle::Result getStructuredBufferRangeSRV(const gl::Context *context, + unsigned int offset, + unsigned int size, + unsigned int structureByteStride, + const d3d11::ShaderResourceView **srvOut); + angle::Result getSRV(const gl::Context *context, + DXGI_FORMAT srvFormat, + const d3d11::ShaderResourceView **srvOut); + angle::Result getRawUAVRange(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + d3d11::UnorderedAccessView **uavOut); + + angle::Result getTypedUAVRange(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + DXGI_FORMAT format, + d3d11::UnorderedAccessView **uavOut); + + angle::Result markRawBufferUsage(const gl::Context *context); + angle::Result markTypedBufferUsage(const gl::Context *context); + bool isMapped() const { return mMappedStorage != nullptr; } + angle::Result packPixels(const gl::Context *context, + const gl::FramebufferAttachment &readAttachment, + const PackPixelsParams ¶ms); + size_t getTotalCPUBufferMemoryBytes() const; + + // BufferD3D implementation + size_t getSize() const override; + bool supportsDirectBinding() const override; + angle::Result getData(const gl::Context *context, const uint8_t **outData) override; + void initializeStaticData(const gl::Context *context) override; + void invalidateStaticData(const gl::Context *context) override; + + // BufferImpl implementation + angle::Result setData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + gl::BufferUsage usage) override; + angle::Result setSubData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + size_t offset) override; + angle::Result copySubData(const gl::Context *context, + BufferImpl *source, + GLintptr sourceOffset, + GLintptr destOffset, + GLsizeiptr size) override; + angle::Result map(const gl::Context *context, GLenum access, void **mapPtr) override; + angle::Result mapRange(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + void **mapPtr) override; + angle::Result unmap(const gl::Context *context, GLboolean *result) override; + angle::Result markTransformFeedbackUsage(const gl::Context *context) override; + + private: + class BufferStorage; + class EmulatedIndexedStorage; + class NativeStorage; + class PackStorage; + class SystemMemoryStorage; + class StructuredBufferStorage; + + struct BufferCacheEntry + { + BufferCacheEntry() : storage(nullptr), lruCount(0) {} + + BufferStorage *storage; + unsigned int lruCount; + }; + + struct StructuredBufferKey + { + StructuredBufferKey(unsigned int offsetIn, unsigned int structureByteStrideIn) + : offset(offsetIn), structureByteStride(structureByteStrideIn) + {} + bool operator<(const StructuredBufferKey &rhs) const + { + return std::tie(offset, structureByteStride) < + std::tie(rhs.offset, rhs.structureByteStride); + } + unsigned int offset; + unsigned int structureByteStride; + }; + + void markBufferUsage(BufferUsage usage); + angle::Result markBufferUsage(const gl::Context *context, BufferUsage usage); + angle::Result garbageCollection(const gl::Context *context, BufferUsage currentUsage); + + angle::Result updateBufferStorage(const gl::Context *context, + BufferStorage *storage, + size_t sourceOffset, + size_t storageSize); + + angle::Result getNativeStorageForUAV(const gl::Context *context, + Buffer11::NativeStorage **storageOut); + + template <typename StorageOutT> + angle::Result getBufferStorage(const gl::Context *context, + BufferUsage usage, + StorageOutT **storageOut); + + template <typename StorageOutT> + angle::Result getStagingStorage(const gl::Context *context, StorageOutT **storageOut); + + angle::Result getLatestBufferStorage(const gl::Context *context, + BufferStorage **storageOut) const; + + angle::Result getConstantBufferRangeStorage(const gl::Context *context, + GLintptr offset, + GLsizeiptr size, + NativeStorage **storageOut); + + BufferStorage *allocateStorage(BufferUsage usage); + void updateDeallocThreshold(BufferUsage usage); + + // Free the storage if we decide it isn't being used very often. + angle::Result checkForDeallocation(const gl::Context *context, BufferUsage usage); + + // For some cases of uniform buffer storage, we can't deallocate system memory storage. + bool canDeallocateSystemMemory() const; + + // Updates data revisions and latest storage. + void onCopyStorage(BufferStorage *dest, BufferStorage *source); + void onStorageUpdate(BufferStorage *updatedStorage); + + Renderer11 *mRenderer; + size_t mSize; + + BufferStorage *mMappedStorage; + + // Buffer storages are sorted by usage. It's important that the latest buffer storage picks + // the lowest usage in the case where two storages are tied on data revision - this ensures + // we never do anything dangerous like map a uniform buffer over a staging or system memory + // copy. + std::array<BufferStorage *, BUFFER_USAGE_COUNT> mBufferStorages; + BufferStorage *mLatestBufferStorage; + + // These two arrays are used to track when to free unused storage. + std::array<unsigned int, BUFFER_USAGE_COUNT> mDeallocThresholds; + std::array<unsigned int, BUFFER_USAGE_COUNT> mIdleness; + + // Cache of D3D11 constant buffer for specific ranges of buffer data. + // This is used to emulate UBO ranges on 11.0 devices. + // Constant buffers are indexed by there start offset. + typedef std::map<GLintptr /*offset*/, BufferCacheEntry> BufferCache; + BufferCache mConstantBufferRangeStoragesCache; + size_t mConstantBufferStorageAdditionalSize; + unsigned int mMaxConstantBufferLruCount; + + typedef std::map<StructuredBufferKey, BufferCacheEntry> StructuredBufferCache; + StructuredBufferCache mStructuredBufferRangeStoragesCache; + size_t mStructuredBufferStorageAdditionalSize; + unsigned int mMaxStructuredBufferLruCount; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp new file mode 100644 index 0000000000..d85b18b840 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp @@ -0,0 +1,813 @@ + +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Clear11.cpp: Framebuffer clear utility class. + +#include "libANGLE/renderer/d3d/d3d11/Clear11.h" + +#include <algorithm> + +#include "libANGLE/Context.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/trace.h" + +// Precompiled shaders +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11_fl9vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewgs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewvs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/cleardepth11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11_fl9ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps1.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps2.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps3.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps4.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps5.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps6.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps7.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps8.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps1.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps2.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps3.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps4.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps5.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps6.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps7.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps8.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps1.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps2.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps3.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps4.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps5.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps6.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps7.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps8.h" + +namespace rx +{ + +namespace +{ +constexpr uint32_t g_ConstantBufferSize = sizeof(RtvDsvClearInfo<float>); +constexpr uint32_t g_VertexSize = sizeof(d3d11::PositionVertex); + +// Updates color, depth and alpha components of cached CB if necessary. +// Returns true if any constants are updated, false otherwise. +template <typename T> +bool UpdateDataCache(RtvDsvClearInfo<T> *dataCache, + const gl::Color<T> &color, + const float *zValue, + const uint32_t numRtvs, + const uint8_t writeMask) +{ + bool cacheDirty = false; + + if (numRtvs > 0) + { + const bool writeRGB = (writeMask & ~D3D11_COLOR_WRITE_ENABLE_ALPHA) != 0; + if (writeRGB && memcmp(&dataCache->r, &color.red, sizeof(T) * 3) != 0) + { + dataCache->r = color.red; + dataCache->g = color.green; + dataCache->b = color.blue; + cacheDirty = true; + } + + const bool writeAlpha = (writeMask & D3D11_COLOR_WRITE_ENABLE_ALPHA) != 0; + if (writeAlpha && (dataCache->a != color.alpha)) + { + dataCache->a = color.alpha; + cacheDirty = true; + } + } + + if (zValue) + { + const float clampedZValue = gl::clamp01(*zValue); + + if (clampedZValue != dataCache->z) + { + dataCache->z = clampedZValue; + cacheDirty = true; + } + } + + return cacheDirty; +} + +} // anonymous namespace + +#define CLEARPS(Index) \ + d3d11::LazyShader<ID3D11PixelShader>(g_PS_Clear##Index, ArraySize(g_PS_Clear##Index), \ + "Clear11 PS " ANGLE_STRINGIFY(Index)) + +Clear11::ShaderManager::ShaderManager() + : mIl9(), + mVs9(g_VS_Clear_FL9, ArraySize(g_VS_Clear_FL9), "Clear11 VS FL9"), + mPsFloat9(g_PS_ClearFloat_FL9, ArraySize(g_PS_ClearFloat_FL9), "Clear11 PS FloatFL9"), + mVs(g_VS_Clear, ArraySize(g_VS_Clear), "Clear11 VS"), + mVsMultiview(g_VS_Multiview_Clear, ArraySize(g_VS_Multiview_Clear), "Clear11 VS Multiview"), + mGsMultiview(g_GS_Multiview_Clear, ArraySize(g_GS_Multiview_Clear), "Clear11 GS Multiview"), + mPsDepth(g_PS_ClearDepth, ArraySize(g_PS_ClearDepth), "Clear11 PS Depth"), + mPsFloat{{CLEARPS(Float1), CLEARPS(Float2), CLEARPS(Float3), CLEARPS(Float4), CLEARPS(Float5), + CLEARPS(Float6), CLEARPS(Float7), CLEARPS(Float8)}}, + mPsUInt{{CLEARPS(Uint1), CLEARPS(Uint2), CLEARPS(Uint3), CLEARPS(Uint4), CLEARPS(Uint5), + CLEARPS(Uint6), CLEARPS(Uint7), CLEARPS(Uint8)}}, + mPsSInt{{CLEARPS(Sint1), CLEARPS(Sint2), CLEARPS(Sint3), CLEARPS(Sint4), CLEARPS(Sint5), + CLEARPS(Sint6), CLEARPS(Sint7), CLEARPS(Sint8)}} +{} + +#undef CLEARPS + +Clear11::ShaderManager::~ShaderManager() {} + +angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *context, + Renderer11 *renderer, + const INT clearType, + const uint32_t numRTs, + const bool hasLayeredLayout, + const d3d11::InputLayout **il, + const d3d11::VertexShader **vs, + const d3d11::GeometryShader **gs, + const d3d11::PixelShader **ps) +{ + Context11 *context11 = GetImplAs<Context11>(context); + + if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + ASSERT(clearType == GL_FLOAT); + + ANGLE_TRY(mVs9.resolve(context11, renderer)); + ANGLE_TRY(mPsFloat9.resolve(context11, renderer)); + + if (!mIl9.valid()) + { + const D3D11_INPUT_ELEMENT_DESC ilDesc[] = { + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}}; + + InputElementArray ilDescArray(ilDesc); + ShaderData vertexShader(g_VS_Clear_FL9); + + ANGLE_TRY(renderer->allocateResource(context11, ilDescArray, &vertexShader, &mIl9)); + } + + *vs = &mVs9.getObj(); + *gs = nullptr; + *il = &mIl9; + *ps = &mPsFloat9.getObj(); + return angle::Result::Continue; + } + + if (!hasLayeredLayout) + { + ANGLE_TRY(mVs.resolve(context11, renderer)); + *vs = &mVs.getObj(); + *gs = nullptr; + } + else + { + // For layered framebuffers we have to use the multi-view versions of the VS and GS. + ANGLE_TRY(mVsMultiview.resolve(context11, renderer)); + ANGLE_TRY(mGsMultiview.resolve(context11, renderer)); + *vs = &mVsMultiview.getObj(); + *gs = &mGsMultiview.getObj(); + } + + *il = nullptr; + + if (numRTs == 0) + { + ANGLE_TRY(mPsDepth.resolve(context11, renderer)); + *ps = &mPsDepth.getObj(); + return angle::Result::Continue; + } + + switch (clearType) + { + case GL_FLOAT: + ANGLE_TRY(mPsFloat[numRTs - 1].resolve(context11, renderer)); + *ps = &mPsFloat[numRTs - 1].getObj(); + break; + case GL_UNSIGNED_INT: + ANGLE_TRY(mPsUInt[numRTs - 1].resolve(context11, renderer)); + *ps = &mPsUInt[numRTs - 1].getObj(); + break; + case GL_INT: + ANGLE_TRY(mPsSInt[numRTs - 1].resolve(context11, renderer)); + *ps = &mPsSInt[numRTs - 1].getObj(); + break; + default: + UNREACHABLE(); + break; + } + + return angle::Result::Continue; +} + +Clear11::Clear11(Renderer11 *renderer) + : mRenderer(renderer), + mResourcesInitialized(false), + mScissorEnabledRasterizerState(), + mScissorDisabledRasterizerState(), + mShaderManager(), + mConstantBuffer(), + mVertexBuffer(), + mShaderData({}) +{} + +Clear11::~Clear11() {} + +angle::Result Clear11::ensureResourcesInitialized(const gl::Context *context) +{ + if (mResourcesInitialized) + { + return angle::Result::Continue; + } + + ANGLE_TRACE_EVENT0("gpu.angle", "Clear11::ensureResourcesInitialized"); + + static_assert((sizeof(RtvDsvClearInfo<float>) == sizeof(RtvDsvClearInfo<int>)), + "Size of rx::RtvDsvClearInfo<float> is not equal to rx::RtvDsvClearInfo<int>"); + + static_assert( + (sizeof(RtvDsvClearInfo<float>) == sizeof(RtvDsvClearInfo<uint32_t>)), + "Size of rx::RtvDsvClearInfo<float> is not equal to rx::RtvDsvClearInfo<uint32_t>"); + + static_assert((sizeof(RtvDsvClearInfo<float>) % 16 == 0), + "The size of RtvDsvClearInfo<float> should be a multiple of 16bytes."); + + // Create Rasterizer States + D3D11_RASTERIZER_DESC rsDesc; + rsDesc.FillMode = D3D11_FILL_SOLID; + rsDesc.CullMode = D3D11_CULL_NONE; + rsDesc.FrontCounterClockwise = FALSE; + rsDesc.DepthBias = 0; + rsDesc.DepthBiasClamp = 0.0f; + rsDesc.SlopeScaledDepthBias = 0.0f; + rsDesc.DepthClipEnable = TRUE; + rsDesc.ScissorEnable = FALSE; + rsDesc.MultisampleEnable = FALSE; + rsDesc.AntialiasedLineEnable = FALSE; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mRenderer->allocateResource(context11, rsDesc, &mScissorDisabledRasterizerState)); + mScissorDisabledRasterizerState.setInternalName("Clear11RasterizerStateWithScissorDisabled"); + + rsDesc.ScissorEnable = TRUE; + ANGLE_TRY(mRenderer->allocateResource(context11, rsDesc, &mScissorEnabledRasterizerState)); + mScissorEnabledRasterizerState.setInternalName("Clear11RasterizerStateWithScissorEnabled"); + + // Initialize Depthstencil state with defaults + mDepthStencilStateKey.depthTest = false; + mDepthStencilStateKey.depthMask = false; + mDepthStencilStateKey.depthFunc = GL_ALWAYS; + mDepthStencilStateKey.stencilWritemask = static_cast<GLuint>(-1); + mDepthStencilStateKey.stencilBackWritemask = static_cast<GLuint>(-1); + mDepthStencilStateKey.stencilBackMask = 0; + mDepthStencilStateKey.stencilTest = false; + mDepthStencilStateKey.stencilMask = 0; + mDepthStencilStateKey.stencilFail = GL_REPLACE; + mDepthStencilStateKey.stencilPassDepthFail = GL_REPLACE; + mDepthStencilStateKey.stencilPassDepthPass = GL_REPLACE; + mDepthStencilStateKey.stencilFunc = GL_ALWAYS; + mDepthStencilStateKey.stencilBackFail = GL_REPLACE; + mDepthStencilStateKey.stencilBackPassDepthFail = GL_REPLACE; + mDepthStencilStateKey.stencilBackPassDepthPass = GL_REPLACE; + mDepthStencilStateKey.stencilBackFunc = GL_ALWAYS; + + // Initialize BlendStateKey with defaults + mBlendStateKey.blendStateExt = gl::BlendStateExt(mRenderer->getNativeCaps().maxDrawBuffers); + + mResourcesInitialized = true; + return angle::Result::Continue; +} + +bool Clear11::useVertexBuffer() const +{ + return (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3); +} + +angle::Result Clear11::ensureConstantBufferCreated(const gl::Context *context) +{ + if (mConstantBuffer.valid()) + { + return angle::Result::Continue; + } + + // Create constant buffer for color & depth data + + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = g_ConstantBufferSize; + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + bufferDesc.MiscFlags = 0; + bufferDesc.StructureByteStride = 0; + + D3D11_SUBRESOURCE_DATA initialData; + initialData.pSysMem = &mShaderData; + initialData.SysMemPitch = g_ConstantBufferSize; + initialData.SysMemSlicePitch = g_ConstantBufferSize; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &initialData, + &mConstantBuffer)); + mConstantBuffer.setInternalName("Clear11ConstantBuffer"); + return angle::Result::Continue; +} + +angle::Result Clear11::ensureVertexBufferCreated(const gl::Context *context) +{ + ASSERT(useVertexBuffer()); + + if (mVertexBuffer.valid()) + { + return angle::Result::Continue; + } + + // Create vertex buffer with vertices for a quad covering the entire surface + + static_assert((sizeof(d3d11::PositionVertex) % 16) == 0, + "d3d11::PositionVertex should be a multiple of 16 bytes"); + const d3d11::PositionVertex vbData[6] = {{-1.0f, 1.0f, 0.0f, 1.0f}, {1.0f, -1.0f, 0.0f, 1.0f}, + {-1.0f, -1.0f, 0.0f, 1.0f}, {-1.0f, 1.0f, 0.0f, 1.0f}, + {1.0f, 1.0f, 0.0f, 1.0f}, {1.0f, -1.0f, 0.0f, 1.0f}}; + + const UINT vbSize = sizeof(vbData); + + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = vbSize; + bufferDesc.Usage = D3D11_USAGE_IMMUTABLE; + bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + bufferDesc.CPUAccessFlags = 0; + bufferDesc.MiscFlags = 0; + bufferDesc.StructureByteStride = 0; + + D3D11_SUBRESOURCE_DATA initialData; + initialData.pSysMem = vbData; + initialData.SysMemPitch = vbSize; + initialData.SysMemSlicePitch = initialData.SysMemPitch; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &initialData, + &mVertexBuffer)); + mVertexBuffer.setInternalName("Clear11VertexBuffer"); + return angle::Result::Continue; +} + +angle::Result Clear11::clearFramebuffer(const gl::Context *context, + const ClearParameters &clearParams, + const gl::FramebufferState &fboData) +{ + ANGLE_TRY(ensureResourcesInitialized(context)); + + // Iterate over the color buffers which require clearing and determine if they can be + // cleared with ID3D11DeviceContext::ClearRenderTargetView or ID3D11DeviceContext1::ClearView. + // This requires: + // 1) The render target is being cleared to a float value (will be cast to integer when clearing + // integer render targets as expected but does not work the other way around) + // 2) The format of the render target has no color channels that are currently masked out. + // Clear the easy-to-clear buffers on the spot and accumulate the ones that require special + // work. + // + // If these conditions are met, and: + // - No scissored clear is needed, then clear using ID3D11DeviceContext::ClearRenderTargetView. + // - A scissored clear is needed then clear using ID3D11DeviceContext1::ClearView if available. + // Otherwise perform a shader based clear. + // + // Also determine if the DSV can be cleared withID3D11DeviceContext::ClearDepthStencilView by + // checking if the stencil write mask covers the entire stencil. + // + // To clear the remaining buffers, a shader based clear is performed: + // - The appropriate ShaderManagers (VS & PS) for the clearType is set + // - A CB containing the clear color and Z values is bound + // - An IL and VB are bound (for FL93 and below) + // - ScissorRect/Raststate/Viewport set as required + // - Blendstate set containing appropriate colorMasks + // - DepthStencilState set with appropriate parameters for a z or stencil clear if required + // - Color and/or Z buffers to be cleared are bound + // - Primitive covering entire clear area is drawn + + gl::Extents framebufferSize; + + const auto *depthStencilAttachment = fboData.getDepthOrStencilAttachment(); + if (depthStencilAttachment != nullptr) + { + framebufferSize = depthStencilAttachment->getSize(); + } + else + { + const gl::FramebufferAttachment *colorAttachment = fboData.getFirstColorAttachment(); + ASSERT(colorAttachment); + framebufferSize = colorAttachment->getSize(); + } + + bool needScissoredClear = false; + D3D11_RECT scissorRect; + if (clearParams.scissorEnabled) + { + if (clearParams.scissor.x >= framebufferSize.width || + clearParams.scissor.y >= framebufferSize.height || clearParams.scissor.width == 0 || + clearParams.scissor.height == 0) + { + // The check assumes that the viewport offsets are not negative as according to the + // OVR_multiview2 spec. + // Scissor rect is outside the renderbuffer or is an empty rect. + return angle::Result::Continue; + } + + if (clearParams.scissor.x + clearParams.scissor.width <= 0 || + clearParams.scissor.y + clearParams.scissor.height <= 0) + { + // Scissor rect is outside the renderbuffer. + return angle::Result::Continue; + } + needScissoredClear = + clearParams.scissor.x > 0 || clearParams.scissor.y > 0 || + clearParams.scissor.x + clearParams.scissor.width < framebufferSize.width || + clearParams.scissor.y + clearParams.scissor.height < framebufferSize.height; + + if (needScissoredClear) + { + // Apply viewport offsets to compute the final scissor rectangles. + // Even in multiview all layers share the same viewport and scissor. + scissorRect.left = clearParams.scissor.x; + scissorRect.right = scissorRect.left + clearParams.scissor.width; + scissorRect.top = clearParams.scissor.y; + scissorRect.bottom = scissorRect.top + clearParams.scissor.height; + } + } + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported(); + + std::array<ID3D11RenderTargetView *, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT> rtvs; + std::array<uint8_t, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT> rtvMasks = {}; + + uint32_t numRtvs = 0; + uint8_t commonColorMask = 0; + + const auto &colorAttachments = fboData.getColorAttachments(); + for (auto colorAttachmentIndex : fboData.getEnabledDrawBuffers()) + { + const uint8_t colorMask = gl::BlendStateExt::ColorMaskStorage::GetValueIndexed( + colorAttachmentIndex, clearParams.colorMask); + + commonColorMask |= colorMask; + + const gl::FramebufferAttachment &attachment = colorAttachments[colorAttachmentIndex]; + + if (!clearParams.clearColor[colorAttachmentIndex]) + { + continue; + } + + RenderTarget11 *renderTarget = nullptr; + ANGLE_TRY(attachment.getRenderTarget(context, attachment.getRenderToTextureSamples(), + &renderTarget)); + + const gl::InternalFormat &formatInfo = *attachment.getFormat().info; + + if (clearParams.colorType == GL_FLOAT && + !(formatInfo.componentType == GL_FLOAT || + formatInfo.componentType == GL_UNSIGNED_NORMALIZED || + formatInfo.componentType == GL_SIGNED_NORMALIZED)) + { + WARN() << "It is undefined behaviour to clear a render buffer which is not " + "normalized fixed point or floating-point to floating point values (color " + "attachment " + << colorAttachmentIndex << " has internal format " << attachment.getFormat() + << ")."; + } + + bool r, g, b, a; + gl::BlendStateExt::UnpackColorMask(colorMask, &r, &g, &b, &a); + if ((formatInfo.redBits == 0 || !r) && (formatInfo.greenBits == 0 || !g) && + (formatInfo.blueBits == 0 || !b) && (formatInfo.alphaBits == 0 || !a)) + { + // Every channel either does not exist in the render target or is masked out + continue; + } + + const auto &framebufferRTV = renderTarget->getRenderTargetView(); + ASSERT(framebufferRTV.valid()); + + bool canClearView = mRenderer->getRenderer11DeviceCaps().supportsClearView; + if (canClearView && + mRenderer->getFeatures().emulateClearViewAfterDualSourceBlending.enabled) + { + // Check the current state to see if we were using dual source blending + const auto isDualSource = [](const auto blend) { + switch (blend) + { + case D3D11_BLEND_SRC1_COLOR: + case D3D11_BLEND_INV_SRC1_COLOR: + case D3D11_BLEND_SRC1_ALPHA: + case D3D11_BLEND_INV_SRC1_ALPHA: + return true; + default: + return false; + } + }; + FLOAT blendFactor[4]; + UINT sampleMask; + ID3D11BlendState *blendState; + deviceContext->OMGetBlendState(&blendState, blendFactor, &sampleMask); + if (blendState) + { + D3D11_BLEND_DESC blendDesc; + blendState->GetDesc(&blendDesc); + // You can only use dual source blending on slot 0 so only check there + if (isDualSource(blendDesc.RenderTarget[0].SrcBlend) || + isDualSource(blendDesc.RenderTarget[0].DestBlend) || + isDualSource(blendDesc.RenderTarget[0].SrcBlendAlpha) || + isDualSource(blendDesc.RenderTarget[0].DestBlendAlpha)) + { + canClearView = false; + } + } + } + + if (needScissoredClear && mRenderer->getFeatures().scissoredClearArtifacts.enabled) + { + canClearView = false; + } + + if ((!canClearView && needScissoredClear) || clearParams.colorType != GL_FLOAT || + (formatInfo.redBits > 0 && !r) || (formatInfo.greenBits > 0 && !g) || + (formatInfo.blueBits > 0 && !b) || (formatInfo.alphaBits > 0 && !a)) + { + rtvs[numRtvs] = framebufferRTV.get(); + rtvMasks[numRtvs] = gl_d3d11::GetColorMask(formatInfo) & colorMask; + numRtvs++; + } + else + { + // ID3D11DeviceContext::ClearRenderTargetView or ID3D11DeviceContext1::ClearView is + // possible + + const auto &nativeFormat = renderTarget->getFormatSet().format(); + + // Check if the actual format has a channel that the internal format does not and + // set them to the default values + float clearValues[4] = { + ((formatInfo.redBits == 0 && nativeFormat.redBits > 0) ? 0.0f + : clearParams.colorF.red), + ((formatInfo.greenBits == 0 && nativeFormat.greenBits > 0) + ? 0.0f + : clearParams.colorF.green), + ((formatInfo.blueBits == 0 && nativeFormat.blueBits > 0) ? 0.0f + : clearParams.colorF.blue), + ((formatInfo.alphaBits == 0 && nativeFormat.alphaBits > 0) + ? 1.0f + : clearParams.colorF.alpha), + }; + + if (formatInfo.alphaBits == 1) + { + // Some drivers do not correctly handle calling Clear() on a format with 1-bit + // alpha. They can incorrectly round all non-zero values up to 1.0f. Note that + // WARP does not do this. We should handle the rounding for them instead. + clearValues[3] = (clearParams.colorF.alpha >= 0.5f) ? 1.0f : 0.0f; + } + + if (needScissoredClear) + { + // We shouldn't reach here if deviceContext1 is unavailable. + ASSERT(deviceContext1); + deviceContext1->ClearView(framebufferRTV.get(), clearValues, &scissorRect, 1); + if (mRenderer->getFeatures().callClearTwice.enabled) + { + deviceContext1->ClearView(framebufferRTV.get(), clearValues, &scissorRect, 1); + } + } + else + { + deviceContext->ClearRenderTargetView(framebufferRTV.get(), clearValues); + if (mRenderer->getFeatures().callClearTwice.enabled) + { + deviceContext->ClearRenderTargetView(framebufferRTV.get(), clearValues); + } + } + } + } + + ID3D11DepthStencilView *dsv = nullptr; + + if (clearParams.clearDepth || clearParams.clearStencil) + { + RenderTarget11 *depthStencilRenderTarget = nullptr; + + ASSERT(depthStencilAttachment != nullptr); + ANGLE_TRY(depthStencilAttachment->getRenderTarget( + context, depthStencilAttachment->getRenderToTextureSamples(), + &depthStencilRenderTarget)); + + dsv = depthStencilRenderTarget->getDepthStencilView().get(); + ASSERT(dsv != nullptr); + + const auto &nativeFormat = depthStencilRenderTarget->getFormatSet().format(); + const auto *stencilAttachment = fboData.getStencilAttachment(); + + uint32_t stencilUnmasked = + (stencilAttachment != nullptr) ? (1 << nativeFormat.stencilBits) - 1 : 0; + bool needMaskedStencilClear = + clearParams.clearStencil && + (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked; + + if (!needScissoredClear && !needMaskedStencilClear) + { + const UINT clearFlags = (clearParams.clearDepth ? D3D11_CLEAR_DEPTH : 0) | + (clearParams.clearStencil ? D3D11_CLEAR_STENCIL : 0); + const FLOAT depthClear = gl::clamp01(clearParams.depthValue); + const UINT8 stencilClear = clearParams.stencilValue & 0xFF; + + deviceContext->ClearDepthStencilView(dsv, clearFlags, depthClear, stencilClear); + + dsv = nullptr; + } + } + + if (numRtvs == 0 && dsv == nullptr) + { + return angle::Result::Continue; + } + + // Clear the remaining render targets and depth stencil in one pass by rendering a quad: + // + // IA/VS: Vertices containing position and color members are passed through to the next stage. + // The vertex position has XY coordinates equal to clip extents and a Z component equal to the + // Z clear value. The vertex color contains the clear color. + // + // Rasterizer: Viewport scales the VS output over the entire surface and depending on whether + // or not scissoring is enabled the appropriate scissor rect and rasterizerState with or without + // the scissor test enabled is set as well. + // + // DepthStencilTest: DepthTesting, DepthWrites, StencilMask and StencilWrites will be enabled or + // disabled or set depending on what the input depthStencil clear parameters are. Since the PS + // is not writing out depth or rejecting pixels, this should happen prior to the PS stage. + // + // PS: Will write out the color values passed through from the previous stage to all outputs. + // + // OM: BlendState will perform the required color masking and output to RTV(s). + + // + // ====================================================================================== + // + // Luckily, the gl spec (ES 3.0.2 pg 183) states that the results of clearing a render- + // buffer that is not normalized fixed point or floating point with floating point values + // are undefined so we can just write floats to them and D3D11 will bit cast them to + // integers. + // + // Also, we don't have to worry about attempting to clear a normalized fixed/floating point + // buffer with integer values because there is no gl API call which would allow it, + // glClearBuffer* calls only clear a single renderbuffer at a time which is verified to + // be a compatible clear type. + + ASSERT(numRtvs <= static_cast<uint32_t>(mRenderer->getNativeCaps().maxDrawBuffers)); + + // Setup BlendStateKey parameters + mBlendStateKey.blendStateExt.setColorMask(false, false, false, false); + for (size_t i = 0; i < numRtvs; i++) + { + mBlendStateKey.blendStateExt.setColorMaskIndexed(i, rtvMasks[i]); + } + + mBlendStateKey.rtvMax = static_cast<uint16_t>(numRtvs); + + // Get BlendState + const d3d11::BlendState *blendState = nullptr; + ANGLE_TRY(mRenderer->getBlendState(context, mBlendStateKey, &blendState)); + + const d3d11::DepthStencilState *dsState = nullptr; + const float *zValue = nullptr; + + if (dsv) + { + // Setup DepthStencilStateKey + mDepthStencilStateKey.depthTest = clearParams.clearDepth; + mDepthStencilStateKey.depthMask = clearParams.clearDepth; + mDepthStencilStateKey.stencilWritemask = clearParams.stencilWriteMask; + mDepthStencilStateKey.stencilTest = clearParams.clearStencil; + + // Get DepthStencilState + ANGLE_TRY(mRenderer->getDepthStencilState(context, mDepthStencilStateKey, &dsState)); + zValue = clearParams.clearDepth ? &clearParams.depthValue : nullptr; + } + + bool dirtyCb = false; + + // Compare the input color/z values against the CB cache and update it if necessary + switch (clearParams.colorType) + { + case GL_FLOAT: + dirtyCb = + UpdateDataCache(&mShaderData, clearParams.colorF, zValue, numRtvs, commonColorMask); + break; + case GL_UNSIGNED_INT: + dirtyCb = UpdateDataCache(reinterpret_cast<RtvDsvClearInfo<uint32_t> *>(&mShaderData), + clearParams.colorUI, zValue, numRtvs, commonColorMask); + break; + case GL_INT: + dirtyCb = UpdateDataCache(reinterpret_cast<RtvDsvClearInfo<int> *>(&mShaderData), + clearParams.colorI, zValue, numRtvs, commonColorMask); + break; + default: + UNREACHABLE(); + break; + } + + ANGLE_TRY(ensureConstantBufferCreated(context)); + + if (dirtyCb) + { + // Update the constant buffer with the updated cache contents + // TODO(Shahmeer): Consider using UpdateSubresource1 D3D11_COPY_DISCARD where possible. + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, + 0, &mappedResource)); + + memcpy(mappedResource.pData, &mShaderData, g_ConstantBufferSize); + deviceContext->Unmap(mConstantBuffer.get(), 0); + } + + auto *stateManager = mRenderer->getStateManager(); + + // Set the viewport to be the same size as the framebuffer. + stateManager->setSimpleViewport(framebufferSize); + + // Apply state + stateManager->setSimpleBlendState(blendState); + + const UINT stencilValue = clearParams.stencilValue & 0xFF; + stateManager->setDepthStencilState(dsState, stencilValue); + + if (needScissoredClear) + { + stateManager->setRasterizerState(&mScissorEnabledRasterizerState); + } + else + { + stateManager->setRasterizerState(&mScissorDisabledRasterizerState); + } + + // Get Shaders + const d3d11::VertexShader *vs = nullptr; + const d3d11::GeometryShader *gs = nullptr; + const d3d11::InputLayout *il = nullptr; + const d3d11::PixelShader *ps = nullptr; + const bool hasLayeredLayout = (fboData.isMultiview()); + ANGLE_TRY(mShaderManager.getShadersAndLayout(context, mRenderer, clearParams.colorType, numRtvs, + hasLayeredLayout, &il, &vs, &gs, &ps)); + + // Apply Shaders + stateManager->setDrawShaders(vs, gs, ps); + stateManager->setPixelConstantBuffer(0, &mConstantBuffer); + + // Bind IL & VB if needed + stateManager->setIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0); + stateManager->setInputLayout(il); + + if (useVertexBuffer()) + { + ANGLE_TRY(ensureVertexBufferCreated(context)); + stateManager->setSingleVertexBuffer(&mVertexBuffer, g_VertexSize, 0); + } + else + { + stateManager->setSingleVertexBuffer(nullptr, 0, 0); + } + + stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + + // Apply render targets + stateManager->setRenderTargets(&rtvs[0], numRtvs, dsv); + + if (needScissoredClear) + { + stateManager->setScissorRectD3D(scissorRect); + } + // Draw the fullscreen quad. + if (!hasLayeredLayout) + { + deviceContext->Draw(6, 0); + } + else + { + ASSERT(hasLayeredLayout); + deviceContext->DrawInstanced(6, static_cast<UINT>(fboData.getNumViews()), 0, 0); + } + + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.h new file mode 100644 index 0000000000..2e2eca5e80 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Clear11.h @@ -0,0 +1,102 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Clear11.h: Framebuffer clear utility class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_CLEAR11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_CLEAR11_H_ + +#include <map> +#include <vector> + +#include "libANGLE/Error.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ +class Renderer11; +class RenderTarget11; +struct ClearParameters; + +template <typename T> +struct RtvDsvClearInfo +{ + T r, g, b, a; + float z; + float c1padding[3]; +}; + +class Clear11 : angle::NonCopyable +{ + public: + explicit Clear11(Renderer11 *renderer); + ~Clear11(); + + // Clears the framebuffer with the supplied clear parameters, assumes that the framebuffer is + // currently applied. + angle::Result clearFramebuffer(const gl::Context *context, + const ClearParameters &clearParams, + const gl::FramebufferState &fboData); + + private: + class ShaderManager final : angle::NonCopyable + { + public: + ShaderManager(); + ~ShaderManager(); + angle::Result getShadersAndLayout(const gl::Context *context, + Renderer11 *renderer, + const INT clearType, + const uint32_t numRTs, + const bool hasLayeredLayout, + const d3d11::InputLayout **il, + const d3d11::VertexShader **vs, + const d3d11::GeometryShader **gs, + const d3d11::PixelShader **ps); + + private: + constexpr static size_t kNumShaders = D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; + + d3d11::InputLayout mIl9; + d3d11::LazyShader<ID3D11VertexShader> mVs9; + d3d11::LazyShader<ID3D11PixelShader> mPsFloat9; + d3d11::LazyShader<ID3D11VertexShader> mVs; + d3d11::LazyShader<ID3D11VertexShader> mVsMultiview; + d3d11::LazyShader<ID3D11GeometryShader> mGsMultiview; + d3d11::LazyShader<ID3D11PixelShader> mPsDepth; + std::array<d3d11::LazyShader<ID3D11PixelShader>, kNumShaders> mPsFloat; + std::array<d3d11::LazyShader<ID3D11PixelShader>, kNumShaders> mPsUInt; + std::array<d3d11::LazyShader<ID3D11PixelShader>, kNumShaders> mPsSInt; + }; + + bool useVertexBuffer() const; + angle::Result ensureConstantBufferCreated(const gl::Context *context); + angle::Result ensureVertexBufferCreated(const gl::Context *context); + angle::Result ensureResourcesInitialized(const gl::Context *context); + + Renderer11 *mRenderer; + bool mResourcesInitialized; + + // States + d3d11::RasterizerState mScissorEnabledRasterizerState; + d3d11::RasterizerState mScissorDisabledRasterizerState; + gl::DepthStencilState mDepthStencilStateKey; + d3d11::BlendStateKey mBlendStateKey; + + // Shaders and shader resources + ShaderManager mShaderManager; + d3d11::Buffer mConstantBuffer; + d3d11::Buffer mVertexBuffer; + + // Buffer data and draw parameters + RtvDsvClearInfo<float> mShaderData; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_CLEAR11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.cpp new file mode 100644 index 0000000000..f3b13f678a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.cpp @@ -0,0 +1,1048 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Context11: +// D3D11-specific functionality associated with a GL Context. +// + +#include "libANGLE/renderer/d3d/d3d11/Context11.h" + +#include "common/entry_points_enum_autogen.h" +#include "common/string_utils.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/MemoryProgramCache.h" +#include "libANGLE/renderer/OverlayImpl.h" +#include "libANGLE/renderer/d3d/CompilerD3D.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/SamplerD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Fence11.h" +#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/IndexBuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Program11.h" +#include "libANGLE/renderer/d3d/d3d11/ProgramPipeline11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/StateManager11.h" +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ + +namespace +{ +ANGLE_INLINE bool DrawCallHasDynamicAttribs(const gl::Context *context) +{ + VertexArray11 *vertexArray11 = GetImplAs<VertexArray11>(context->getState().getVertexArray()); + return vertexArray11->hasActiveDynamicAttrib(context); +} + +bool DrawCallHasStreamingVertexArrays(const gl::Context *context, gl::PrimitiveMode mode) +{ + // Direct drawing doesn't support dynamic attribute storage since it needs the first and count + // to translate when applyVertexBuffer. GL_LINE_LOOP and GL_TRIANGLE_FAN are not supported + // either since we need to simulate them in D3D. + if (DrawCallHasDynamicAttribs(context) || mode == gl::PrimitiveMode::LineLoop || + mode == gl::PrimitiveMode::TriangleFan) + { + return true; + } + + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(context->getState().getProgram()); + if (InstancedPointSpritesActive(programD3D, mode)) + { + return true; + } + + return false; +} + +bool DrawCallHasStreamingElementArray(const gl::Context *context, gl::DrawElementsType srcType) +{ + const gl::State &glState = context->getState(); + gl::Buffer *elementArrayBuffer = glState.getVertexArray()->getElementArrayBuffer(); + + bool primitiveRestartWorkaround = + UsePrimitiveRestartWorkaround(glState.isPrimitiveRestartEnabled(), srcType); + const gl::DrawElementsType dstType = + (srcType == gl::DrawElementsType::UnsignedInt || primitiveRestartWorkaround) + ? gl::DrawElementsType::UnsignedInt + : gl::DrawElementsType::UnsignedShort; + + // Not clear where the offset comes from here. + switch (ClassifyIndexStorage(glState, elementArrayBuffer, srcType, dstType, 0)) + { + case IndexStorageType::Dynamic: + return true; + case IndexStorageType::Direct: + return false; + case IndexStorageType::Static: + { + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(elementArrayBuffer); + StaticIndexBufferInterface *staticBuffer = bufferD3D->getStaticIndexBuffer(); + return (staticBuffer->getBufferSize() == 0 || staticBuffer->getIndexType() != dstType); + } + default: + UNREACHABLE(); + return true; + } +} + +template <typename IndirectBufferT> +angle::Result ReadbackIndirectBuffer(const gl::Context *context, + const void *indirect, + const IndirectBufferT **bufferPtrOut) +{ + const gl::State &glState = context->getState(); + gl::Buffer *drawIndirectBuffer = glState.getTargetBuffer(gl::BufferBinding::DrawIndirect); + ASSERT(drawIndirectBuffer); + Buffer11 *storage = GetImplAs<Buffer11>(drawIndirectBuffer); + uintptr_t offset = reinterpret_cast<uintptr_t>(indirect); + + const uint8_t *bufferData = nullptr; + ANGLE_TRY(storage->getData(context, &bufferData)); + ASSERT(bufferData); + + *bufferPtrOut = reinterpret_cast<const IndirectBufferT *>(bufferData + offset); + return angle::Result::Continue; +} +} // anonymous namespace + +Context11::Context11(const gl::State &state, gl::ErrorSet *errorSet, Renderer11 *renderer) + : ContextD3D(state, errorSet), mRenderer(renderer) +{} + +Context11::~Context11() {} + +angle::Result Context11::initialize() +{ + return angle::Result::Continue; +} + +void Context11::onDestroy(const gl::Context *context) +{ + mIncompleteTextures.onDestroy(context); +} + +CompilerImpl *Context11::createCompiler() +{ + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + return new CompilerD3D(SH_HLSL_4_0_FL9_3_OUTPUT); + } + else + { + return new CompilerD3D(SH_HLSL_4_1_OUTPUT); + } +} + +ShaderImpl *Context11::createShader(const gl::ShaderState &data) +{ + return new ShaderD3D(data, mRenderer); +} + +ProgramImpl *Context11::createProgram(const gl::ProgramState &data) +{ + return new Program11(data, mRenderer); +} + +FramebufferImpl *Context11::createFramebuffer(const gl::FramebufferState &data) +{ + return new Framebuffer11(data, mRenderer); +} + +TextureImpl *Context11::createTexture(const gl::TextureState &state) +{ + switch (state.getType()) + { + case gl::TextureType::_2D: + // GL_TEXTURE_VIDEO_IMAGE_WEBGL maps to native 2D texture on Windows platform + case gl::TextureType::VideoImage: + return new TextureD3D_2D(state, mRenderer); + case gl::TextureType::CubeMap: + return new TextureD3D_Cube(state, mRenderer); + case gl::TextureType::_3D: + return new TextureD3D_3D(state, mRenderer); + case gl::TextureType::_2DArray: + return new TextureD3D_2DArray(state, mRenderer); + case gl::TextureType::External: + return new TextureD3D_External(state, mRenderer); + case gl::TextureType::_2DMultisample: + return new TextureD3D_2DMultisample(state, mRenderer); + case gl::TextureType::_2DMultisampleArray: + return new TextureD3D_2DMultisampleArray(state, mRenderer); + case gl::TextureType::Buffer: + return new TextureD3D_Buffer(state, mRenderer); + default: + UNREACHABLE(); + } + + return nullptr; +} + +RenderbufferImpl *Context11::createRenderbuffer(const gl::RenderbufferState &state) +{ + return new RenderbufferD3D(state, mRenderer); +} + +BufferImpl *Context11::createBuffer(const gl::BufferState &state) +{ + Buffer11 *buffer = new Buffer11(state, mRenderer); + mRenderer->onBufferCreate(buffer); + return buffer; +} + +VertexArrayImpl *Context11::createVertexArray(const gl::VertexArrayState &data) +{ + return new VertexArray11(data); +} + +QueryImpl *Context11::createQuery(gl::QueryType type) +{ + return new Query11(mRenderer, type); +} + +FenceNVImpl *Context11::createFenceNV() +{ + return new FenceNV11(mRenderer); +} + +SyncImpl *Context11::createSync() +{ + return new Sync11(mRenderer); +} + +TransformFeedbackImpl *Context11::createTransformFeedback(const gl::TransformFeedbackState &state) +{ + return new TransformFeedback11(state, mRenderer); +} + +SamplerImpl *Context11::createSampler(const gl::SamplerState &state) +{ + return new SamplerD3D(state); +} + +ProgramPipelineImpl *Context11::createProgramPipeline(const gl::ProgramPipelineState &data) +{ + return new ProgramPipeline11(data); +} + +MemoryObjectImpl *Context11::createMemoryObject() +{ + UNREACHABLE(); + return nullptr; +} + +SemaphoreImpl *Context11::createSemaphore() +{ + UNREACHABLE(); + return nullptr; +} + +OverlayImpl *Context11::createOverlay(const gl::OverlayState &state) +{ + // Not implemented. + return new OverlayImpl(state); +} + +angle::Result Context11::flush(const gl::Context *context) +{ + return mRenderer->flush(this); +} + +angle::Result Context11::finish(const gl::Context *context) +{ + return mRenderer->finish(this); +} + +angle::Result Context11::drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count) +{ + ASSERT(count > 0); + ANGLE_TRY(mRenderer->getStateManager()->updateState( + context, mode, first, count, gl::DrawElementsType::InvalidEnum, nullptr, 0, 0, 0, true)); + return mRenderer->drawArrays(context, mode, first, count, 0, 0, false); +} + +angle::Result Context11::drawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount) +{ + ASSERT(count > 0); + ANGLE_TRY(mRenderer->getStateManager()->updateState(context, mode, first, count, + gl::DrawElementsType::InvalidEnum, nullptr, + instanceCount, 0, 0, true)); + return mRenderer->drawArrays(context, mode, first, count, instanceCount, 0, true); +} + +angle::Result Context11::drawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) +{ + ASSERT(count > 0); + ANGLE_TRY(mRenderer->getStateManager()->updateState(context, mode, first, count, + gl::DrawElementsType::InvalidEnum, nullptr, + instanceCount, 0, baseInstance, true)); + return mRenderer->drawArrays(context, mode, first, count, instanceCount, baseInstance, true); +} + +ANGLE_INLINE angle::Result Context11::drawElementsImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic, + bool isInstancedDraw) +{ + ASSERT(indexCount > 0); + + if (DrawCallHasDynamicAttribs(context)) + { + gl::IndexRange indexRange; + ANGLE_TRY(context->getState().getVertexArray()->getIndexRange( + context, indexType, indexCount, indices, &indexRange)); + GLint startVertex; + ANGLE_TRY(ComputeStartVertex(GetImplAs<Context11>(context), indexRange, baseVertex, + &startVertex)); + ANGLE_TRY(mRenderer->getStateManager()->updateState( + context, mode, startVertex, indexCount, indexType, indices, instanceCount, baseVertex, + baseInstance, promoteDynamic)); + return mRenderer->drawElements(context, mode, startVertex, indexCount, indexType, indices, + instanceCount, baseVertex, baseInstance, isInstancedDraw); + } + else + { + ANGLE_TRY(mRenderer->getStateManager()->updateState(context, mode, 0, indexCount, indexType, + indices, instanceCount, baseVertex, + baseInstance, promoteDynamic)); + return mRenderer->drawElements(context, mode, 0, indexCount, indexType, indices, + instanceCount, baseVertex, baseInstance, isInstancedDraw); + } +} + +angle::Result Context11::drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices) +{ + return drawElementsImpl(context, mode, count, type, indices, 0, 0, 0, true, false); +} + +angle::Result Context11::drawElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) +{ + return drawElementsImpl(context, mode, count, type, indices, 0, baseVertex, 0, true, false); +} + +angle::Result Context11::drawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) +{ + return drawElementsImpl(context, mode, count, type, indices, instances, 0, 0, true, true); +} + +angle::Result Context11::drawElementsInstancedBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex) +{ + return drawElementsImpl(context, mode, count, type, indices, instances, baseVertex, 0, true, + true); +} + +angle::Result Context11::drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance) +{ + return drawElementsImpl(context, mode, count, type, indices, instances, baseVertex, + baseInstance, true, true); +} + +angle::Result Context11::drawRangeElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices) +{ + return drawElementsImpl(context, mode, count, type, indices, 0, 0, 0, true, false); +} + +angle::Result Context11::drawRangeElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) +{ + return drawElementsImpl(context, mode, count, type, indices, 0, baseVertex, 0, true, false); +} + +angle::Result Context11::drawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect) +{ + if (DrawCallHasStreamingVertexArrays(context, mode)) + { + const gl::DrawArraysIndirectCommand *cmd = nullptr; + ANGLE_TRY(ReadbackIndirectBuffer(context, indirect, &cmd)); + + ANGLE_TRY(mRenderer->getStateManager()->updateState( + context, mode, cmd->first, cmd->count, gl::DrawElementsType::InvalidEnum, nullptr, + cmd->instanceCount, 0, 0, true)); + return mRenderer->drawArrays(context, mode, cmd->first, cmd->count, cmd->instanceCount, + cmd->baseInstance, true); + } + else + { + ANGLE_TRY(mRenderer->getStateManager()->updateState( + context, mode, 0, 0, gl::DrawElementsType::InvalidEnum, nullptr, 0, 0, 0, true)); + return mRenderer->drawArraysIndirect(context, indirect); + } +} + +angle::Result Context11::drawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect) +{ + if (DrawCallHasStreamingVertexArrays(context, mode) || + DrawCallHasStreamingElementArray(context, type)) + { + const gl::DrawElementsIndirectCommand *cmd = nullptr; + ANGLE_TRY(ReadbackIndirectBuffer(context, indirect, &cmd)); + + const GLuint typeBytes = gl::GetDrawElementsTypeSize(type); + const void *indices = + reinterpret_cast<const void *>(static_cast<uintptr_t>(cmd->firstIndex * typeBytes)); + + // We must explicitly resolve the index range for the slow-path indirect drawElements to + // make sure we are using the correct 'baseVertex'. This parameter does not exist for the + // direct drawElements. + gl::IndexRange indexRange; + ANGLE_TRY(context->getState().getVertexArray()->getIndexRange(context, type, cmd->count, + indices, &indexRange)); + + GLint startVertex; + ANGLE_TRY(ComputeStartVertex(GetImplAs<Context11>(context), indexRange, cmd->baseVertex, + &startVertex)); + + ANGLE_TRY(mRenderer->getStateManager()->updateState( + context, mode, startVertex, cmd->count, type, indices, cmd->primCount, cmd->baseVertex, + cmd->baseInstance, true)); + return mRenderer->drawElements(context, mode, static_cast<GLint>(indexRange.start), + cmd->count, type, indices, cmd->primCount, 0, 0, true); + } + else + { + ANGLE_TRY(mRenderer->getStateManager()->updateState(context, mode, 0, 0, type, nullptr, 0, + 0, 0, true)); + return mRenderer->drawElementsIndirect(context, indirect); + } +} + +#define DRAW_ARRAYS__ \ + { \ + ANGLE_TRY(mRenderer->getStateManager()->updateState( \ + context, mode, firsts[drawID], counts[drawID], gl::DrawElementsType::InvalidEnum, \ + nullptr, 0, 0, 0, false)); \ + ANGLE_TRY( \ + mRenderer->drawArrays(context, mode, firsts[drawID], counts[drawID], 0, 0, false)); \ + } +#define DRAW_ARRAYS_INSTANCED_ \ + { \ + ANGLE_TRY(mRenderer->getStateManager()->updateState( \ + context, mode, firsts[drawID], counts[drawID], gl::DrawElementsType::InvalidEnum, \ + nullptr, instanceCounts[drawID], 0, 0, false)); \ + ANGLE_TRY(mRenderer->drawArrays(context, mode, firsts[drawID], counts[drawID], \ + instanceCounts[drawID], 0, true)); \ + } +#define DRAW_ARRAYS_INSTANCED_BASE_INSTANCE \ + { \ + ANGLE_TRY(mRenderer->getStateManager()->updateState( \ + context, mode, firsts[drawID], counts[drawID], gl::DrawElementsType::InvalidEnum, \ + nullptr, instanceCounts[drawID], 0, baseInstances[drawID], false)); \ + ANGLE_TRY(mRenderer->drawArrays(context, mode, firsts[drawID], counts[drawID], \ + instanceCounts[drawID], baseInstances[drawID], true)); \ + } +#define DRAW_ELEMENTS__ \ + { \ + ANGLE_TRY(drawElementsImpl(context, mode, counts[drawID], type, indices[drawID], 0, 0, 0, \ + false, false)); \ + } +#define DRAW_ELEMENTS_INSTANCED_ \ + { \ + ANGLE_TRY(drawElementsImpl(context, mode, counts[drawID], type, indices[drawID], \ + instanceCounts[drawID], 0, 0, false, true)); \ + } +#define DRAW_ELEMENTS_INSTANCED_BASE_VERTEX_BASE_INSTANCE \ + { \ + ANGLE_TRY(drawElementsImpl(context, mode, counts[drawID], type, indices[drawID], \ + instanceCounts[drawID], baseVertices[drawID], \ + baseInstances[drawID], false, true)); \ + } + +#define DRAW_CALL(drawType, instanced, bvbi) DRAW_##drawType##instanced##bvbi + +#define MULTI_DRAW_BLOCK(drawType, instanced, bvbi, hasDrawID, hasBaseVertex, hasBaseInstance) \ + for (GLsizei drawID = 0; drawID < drawcount; ++drawID) \ + { \ + if (ANGLE_NOOP_DRAW(instanced)) \ + { \ + continue; \ + } \ + ANGLE_SET_DRAW_ID_UNIFORM(hasDrawID)(drawID); \ + ANGLE_SET_BASE_VERTEX_UNIFORM(hasBaseVertex)(baseVertices[drawID]); \ + ANGLE_SET_BASE_INSTANCE_UNIFORM(hasBaseInstance)(baseInstances[drawID]); \ + ASSERT(counts[drawID] > 0); \ + DRAW_CALL(drawType, instanced, bvbi); \ + ANGLE_MARK_TRANSFORM_FEEDBACK_USAGE(instanced); \ + gl::MarkShaderStorageUsage(context); \ + } + +angle::Result Context11::multiDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + if (hasDrawID) + { + MULTI_DRAW_BLOCK(ARRAYS, _, _, 1, 0, 0) + } + else + { + MULTI_DRAW_BLOCK(ARRAYS, _, _, 0, 0, 0) + } + + return angle::Result::Continue; +} + +angle::Result Context11::multiDrawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + if (hasDrawID) + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _, 1, 0, 0) + } + else + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _, 0, 0, 0) + } + + return angle::Result::Continue; +} + +angle::Result Context11::multiDrawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return rx::MultiDrawArraysIndirectGeneral(this, context, mode, indirect, drawcount, stride); +} + +angle::Result Context11::multiDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + if (hasDrawID) + { + MULTI_DRAW_BLOCK(ELEMENTS, _, _, 1, 0, 0) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _, _, 0, 0, 0) + } + + return angle::Result::Continue; +} + +angle::Result Context11::multiDrawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + if (hasDrawID) + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _, 1, 0, 0) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _, 0, 0, 0) + } + + return angle::Result::Continue; +} + +angle::Result Context11::multiDrawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return rx::MultiDrawElementsIndirectGeneral(this, context, mode, type, indirect, drawcount, + stride); +} + +angle::Result Context11::multiDrawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + const bool hasBaseInstance = programObject && programObject->hasBaseInstanceUniform(); + ResetBaseVertexBaseInstance resetUniforms(programObject, false, hasBaseInstance); + + if (hasDrawID && hasBaseInstance) + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 1, 0, 1) + } + else if (hasDrawID) + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 1, 0, 0) + } + else if (hasBaseInstance) + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 0, 0, 1) + } + else + { + MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 0, 0, 0) + } + + return angle::Result::Continue; +} + +angle::Result Context11::multiDrawElementsInstancedBaseVertexBaseInstance( + const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) +{ + gl::Program *programObject = context->getState().getLinkedProgram(context); + const bool hasDrawID = programObject && programObject->hasDrawIDUniform(); + const bool hasBaseVertex = programObject && programObject->hasBaseVertexUniform(); + const bool hasBaseInstance = programObject && programObject->hasBaseInstanceUniform(); + ResetBaseVertexBaseInstance resetUniforms(programObject, hasBaseVertex, hasBaseInstance); + + if (hasDrawID) + { + if (hasBaseVertex) + { + if (hasBaseInstance) + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 1, 1) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 1, 0) + } + } + else + { + if (hasBaseInstance) + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 0, 1) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 0, 0) + } + } + } + else + { + if (hasBaseVertex) + { + if (hasBaseInstance) + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 1, 1) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 1, 0) + } + } + else + { + if (hasBaseInstance) + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 0, 1) + } + else + { + MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 0, 0) + } + } + } + + return angle::Result::Continue; +} + +gl::GraphicsResetStatus Context11::getResetStatus() +{ + return mRenderer->getResetStatus(); +} + +angle::Result Context11::insertEventMarker(GLsizei length, const char *marker) +{ + mRenderer->getDebugAnnotatorContext()->setMarker(marker); + return angle::Result::Continue; +} + +angle::Result Context11::pushGroupMarker(GLsizei length, const char *marker) +{ + mRenderer->getDebugAnnotatorContext()->beginEvent(angle::EntryPoint::GLPushGroupMarkerEXT, + marker, marker); + mMarkerStack.push(std::string(marker)); + return angle::Result::Continue; +} + +angle::Result Context11::popGroupMarker() +{ + const char *marker = nullptr; + if (!mMarkerStack.empty()) + { + marker = mMarkerStack.top().c_str(); + mMarkerStack.pop(); + mRenderer->getDebugAnnotatorContext()->endEvent(marker, + angle::EntryPoint::GLPopGroupMarkerEXT); + } + return angle::Result::Continue; +} + +angle::Result Context11::pushDebugGroup(const gl::Context *context, + GLenum source, + GLuint id, + const std::string &message) +{ + // Fall through to the EXT_debug_marker functions + return pushGroupMarker(static_cast<GLsizei>(message.size()), message.c_str()); +} + +angle::Result Context11::popDebugGroup(const gl::Context *context) +{ + // Fall through to the EXT_debug_marker functions + return popGroupMarker(); +} + +angle::Result Context11::syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + const gl::State::DirtyBits &bitMask, + gl::Command command) +{ + mRenderer->getStateManager()->syncState(context, dirtyBits, command); + return angle::Result::Continue; +} + +GLint Context11::getGPUDisjoint() +{ + return mRenderer->getGPUDisjoint(); +} + +GLint64 Context11::getTimestamp() +{ + return mRenderer->getTimestamp(); +} + +angle::Result Context11::onMakeCurrent(const gl::Context *context) +{ + // Immediately return if the device has been lost. + if (!mRenderer->getDevice()) + { + return angle::Result::Continue; + } + + return mRenderer->getStateManager()->onMakeCurrent(context); +} + +gl::Caps Context11::getNativeCaps() const +{ + gl::Caps caps = mRenderer->getNativeCaps(); + + // For pixel shaders, the render targets and unordered access views share the same resource + // slots, so the maximum number of fragment shader outputs depends on the current context + // version: + // - If current context is ES 3.0 and below, we use D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT(8) + // as the value of max draw buffers because UAVs are not used. + // - If current context is ES 3.1 and the feature level is 11_0, the RTVs and UAVs share 8 + // slots. As ES 3.1 requires at least 1 atomic counter buffer in compute shaders, the value + // of max combined shader output resources is limited to 7, thus only 7 RTV slots can be + // used simultaneously. + // - If current context is ES 3.1 and the feature level is 11_1, the RTVs and UAVs share 64 + // slots. Currently we allocate 60 slots for combined shader output resources, so we can use + // at most D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT(8) RTVs simultaneously. + if (mState.getClientVersion() >= gl::ES_3_1 && + mRenderer->getRenderer11DeviceCaps().featureLevel == D3D_FEATURE_LEVEL_11_0) + { + caps.maxDrawBuffers = caps.maxCombinedShaderOutputResources; + caps.maxColorAttachments = caps.maxCombinedShaderOutputResources; + } + + return caps; +} + +const gl::TextureCapsMap &Context11::getNativeTextureCaps() const +{ + return mRenderer->getNativeTextureCaps(); +} + +const gl::Extensions &Context11::getNativeExtensions() const +{ + return mRenderer->getNativeExtensions(); +} + +const gl::Limitations &Context11::getNativeLimitations() const +{ + return mRenderer->getNativeLimitations(); +} + +ShPixelLocalStorageType Context11::getNativePixelLocalStorageType() const +{ + return mRenderer->getNativePixelLocalStorageType(); +} + +angle::Result Context11::dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) +{ + return mRenderer->dispatchCompute(context, numGroupsX, numGroupsY, numGroupsZ); +} + +angle::Result Context11::dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) +{ + return mRenderer->dispatchComputeIndirect(context, indirect); +} + +angle::Result Context11::triggerDrawCallProgramRecompilation(const gl::Context *context, + gl::PrimitiveMode drawMode) +{ + const auto &glState = context->getState(); + const auto *va11 = GetImplAs<VertexArray11>(glState.getVertexArray()); + const auto *drawFBO = glState.getDrawFramebuffer(); + gl::Program *program = glState.getProgram(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + + programD3D->updateCachedInputLayout(va11->getCurrentStateSerial(), glState); + programD3D->updateCachedOutputLayout(context, drawFBO); + + bool recompileVS = !programD3D->hasVertexExecutableForCachedInputLayout(); + bool recompileGS = !programD3D->hasGeometryExecutableForPrimitiveType(glState, drawMode); + bool recompilePS = !programD3D->hasPixelExecutableForCachedOutputLayout(); + + if (!recompileVS && !recompileGS && !recompilePS) + { + return angle::Result::Continue; + } + + // Load the compiler if necessary and recompile the programs. + ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized(this)); + + gl::InfoLog infoLog; + + if (recompileVS) + { + ShaderExecutableD3D *vertexExe = nullptr; + ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(this, &vertexExe, &infoLog)); + if (!programD3D->hasVertexExecutableForCachedInputLayout()) + { + ASSERT(infoLog.getLength() > 0); + ERR() << "Error compiling dynamic vertex executable: " << infoLog.str(); + ANGLE_TRY_HR(this, E_FAIL, "Error compiling dynamic vertex executable"); + } + } + + if (recompileGS) + { + ShaderExecutableD3D *geometryExe = nullptr; + ANGLE_TRY(programD3D->getGeometryExecutableForPrimitiveType(this, glState, drawMode, + &geometryExe, &infoLog)); + if (!programD3D->hasGeometryExecutableForPrimitiveType(glState, drawMode)) + { + ASSERT(infoLog.getLength() > 0); + ERR() << "Error compiling dynamic geometry executable: " << infoLog.str(); + ANGLE_TRY_HR(this, E_FAIL, "Error compiling dynamic geometry executable"); + } + } + + if (recompilePS) + { + ShaderExecutableD3D *pixelExe = nullptr; + ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(this, &pixelExe, &infoLog)); + if (!programD3D->hasPixelExecutableForCachedOutputLayout()) + { + ASSERT(infoLog.getLength() > 0); + ERR() << "Error compiling dynamic pixel executable: " << infoLog.str(); + ANGLE_TRY_HR(this, E_FAIL, "Error compiling dynamic pixel executable"); + } + } + + // Refresh the program cache entry. + if (mMemoryProgramCache) + { + ANGLE_TRY(mMemoryProgramCache->updateProgram(context, program)); + } + + return angle::Result::Continue; +} + +angle::Result Context11::triggerDispatchCallProgramRecompilation(const gl::Context *context) +{ + const auto &glState = context->getState(); + gl::Program *program = glState.getProgram(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + + programD3D->updateCachedComputeImage2DBindLayout(context); + + bool recompileCS = !programD3D->hasComputeExecutableForCachedImage2DBindLayout(); + + if (!recompileCS) + { + return angle::Result::Continue; + } + + // Load the compiler if necessary and recompile the programs. + ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized(this)); + + gl::InfoLog infoLog; + + ShaderExecutableD3D *computeExe = nullptr; + ANGLE_TRY( + programD3D->getComputeExecutableForImage2DBindLayout(context, this, &computeExe, &infoLog)); + if (!programD3D->hasComputeExecutableForCachedImage2DBindLayout()) + { + ASSERT(infoLog.getLength() > 0); + ERR() << "Dynamic recompilation error log: " << infoLog.str(); + ANGLE_TRY_HR(this, E_FAIL, "Error compiling dynamic compute executable"); + } + + // Refresh the program cache entry. + if (mMemoryProgramCache) + { + ANGLE_TRY(mMemoryProgramCache->updateProgram(context, program)); + } + + return angle::Result::Continue; +} + +angle::Result Context11::memoryBarrier(const gl::Context *context, GLbitfield barriers) +{ + return angle::Result::Continue; +} + +angle::Result Context11::memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) +{ + return angle::Result::Continue; +} + +angle::Result Context11::getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) +{ + return mIncompleteTextures.getIncompleteTexture(context, type, gl::SamplerFormat::Float, this, + textureOut); +} + +angle::Result Context11::initializeMultisampleTextureToBlack(const gl::Context *context, + gl::Texture *glTexture) +{ + ASSERT(glTexture->getType() == gl::TextureType::_2DMultisample); + TextureD3D *textureD3D = GetImplAs<TextureD3D>(glTexture); + gl::ImageIndex index = gl::ImageIndex::Make2DMultisample(); + RenderTargetD3D *renderTarget = nullptr; + GLsizei texSamples = textureD3D->getRenderToTextureSamples(); + ANGLE_TRY(textureD3D->getRenderTarget(context, index, texSamples, &renderTarget)); + return mRenderer->clearRenderTarget(context, renderTarget, gl::ColorF(0.0f, 0.0f, 0.0f, 1.0f), + 1.0f, 0); +} + +void Context11::handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) +{ + ASSERT(FAILED(hr)); + + GLenum glErrorCode = DefaultGLErrorCode(hr); + + std::stringstream errorStream; + errorStream << "Internal D3D11 error: " << gl::FmtHR(hr); + + if (d3d11::isDeviceLostError(hr)) + { + HRESULT removalReason = mRenderer->getDevice()->GetDeviceRemovedReason(); + errorStream << " (removal reason: " << gl::FmtHR(removalReason) << ")"; + mRenderer->notifyDeviceLost(); + } + + errorStream << ": " << message; + + mErrors->handleError(glErrorCode, errorStream.str().c_str(), file, function, line); +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.h new file mode 100644 index 0000000000..5f84e410b5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Context11.h @@ -0,0 +1,282 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Context11: +// D3D11-specific functionality associated with a GL Context. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_ + +#include <stack> +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/ContextD3D.h" + +namespace rx +{ +class Renderer11; + +class Context11 : public ContextD3D, public MultisampleTextureInitializer +{ + public: + Context11(const gl::State &state, gl::ErrorSet *errorSet, Renderer11 *renderer); + ~Context11() override; + + angle::Result initialize() override; + void onDestroy(const gl::Context *context) override; + + // Shader creation + CompilerImpl *createCompiler() override; + ShaderImpl *createShader(const gl::ShaderState &data) override; + ProgramImpl *createProgram(const gl::ProgramState &data) override; + + // Framebuffer creation + FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override; + + // Texture creation + TextureImpl *createTexture(const gl::TextureState &state) override; + + // Renderbuffer creation + RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override; + + // Buffer creation + BufferImpl *createBuffer(const gl::BufferState &state) override; + + // Vertex Array creation + VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override; + + // Query and Fence creation + QueryImpl *createQuery(gl::QueryType type) override; + FenceNVImpl *createFenceNV() override; + SyncImpl *createSync() override; + + // Transform Feedback creation + TransformFeedbackImpl *createTransformFeedback( + const gl::TransformFeedbackState &state) override; + + // Sampler object creation + SamplerImpl *createSampler(const gl::SamplerState &state) override; + + // Program Pipeline object creation + ProgramPipelineImpl *createProgramPipeline(const gl::ProgramPipelineState &data) override; + + // Memory object creation. + MemoryObjectImpl *createMemoryObject() override; + + // Semaphore creation. + SemaphoreImpl *createSemaphore() override; + + // Overlay creation. + OverlayImpl *createOverlay(const gl::OverlayState &state) override; + + // Flush and finish. + angle::Result flush(const gl::Context *context) override; + angle::Result finish(const gl::Context *context) override; + + // Drawing methods. + angle::Result drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count) override; + angle::Result drawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount) override; + angle::Result drawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) override; + + angle::Result drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices) override; + angle::Result drawElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) override; + angle::Result drawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) override; + angle::Result drawElementsInstancedBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex) override; + angle::Result drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance) override; + angle::Result drawRangeElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices) override; + angle::Result drawRangeElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) override; + angle::Result drawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect) override; + angle::Result drawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect) override; + + angle::Result multiDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) override; + angle::Result multiDrawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) override; + angle::Result multiDrawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) override; + angle::Result multiDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + GLsizei drawcount) override; + angle::Result multiDrawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) override; + angle::Result multiDrawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) override; + angle::Result multiDrawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) override; + angle::Result multiDrawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) override; + + // Device loss + gl::GraphicsResetStatus getResetStatus() override; + + // EXT_debug_marker + angle::Result insertEventMarker(GLsizei length, const char *marker) override; + angle::Result pushGroupMarker(GLsizei length, const char *marker) override; + angle::Result popGroupMarker() override; + + // KHR_debug + angle::Result pushDebugGroup(const gl::Context *context, + GLenum source, + GLuint id, + const std::string &message) override; + angle::Result popDebugGroup(const gl::Context *context) override; + + // State sync with dirty bits. + angle::Result syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + const gl::State::DirtyBits &bitMask, + gl::Command command) override; + + // Disjoint timer queries + GLint getGPUDisjoint() override; + GLint64 getTimestamp() override; + + // Context switching + angle::Result onMakeCurrent(const gl::Context *context) override; + + // Caps queries + gl::Caps getNativeCaps() const override; + const gl::TextureCapsMap &getNativeTextureCaps() const override; + const gl::Extensions &getNativeExtensions() const override; + const gl::Limitations &getNativeLimitations() const override; + ShPixelLocalStorageType getNativePixelLocalStorageType() const override; + + Renderer11 *getRenderer() const { return mRenderer; } + + angle::Result dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) override; + angle::Result dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) override; + + angle::Result memoryBarrier(const gl::Context *context, GLbitfield barriers) override; + angle::Result memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) override; + + angle::Result triggerDrawCallProgramRecompilation(const gl::Context *context, + gl::PrimitiveMode drawMode); + angle::Result triggerDispatchCallProgramRecompilation(const gl::Context *context); + angle::Result getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut); + + angle::Result initializeMultisampleTextureToBlack(const gl::Context *context, + gl::Texture *glTexture) override; + + void handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) override; + + private: + angle::Result drawElementsImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic, + bool isInstancedDraw); + + Renderer11 *mRenderer; + IncompleteTextureSet mIncompleteTextures; + std::stack<std::string> mMarkerStack; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp new file mode 100644 index 0000000000..2b947d8957 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp @@ -0,0 +1,148 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DebugAnnotator11.cpp: D3D11 helpers for adding trace annotations. +// + +#include "libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h" + +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include <versionhelpers.h> + +#include "common/system_utils.h" + +namespace rx +{ + +// DebugAnnotator11 implementation +DebugAnnotator11::DebugAnnotator11() {} + +DebugAnnotator11::~DebugAnnotator11() {} + +void DebugAnnotator11::beginEvent(gl::Context *context, + angle::EntryPoint entryPoint, + const char *eventName, + const char *eventMessage) +{ + angle::LoggingAnnotator::beginEvent(context, entryPoint, eventName, eventMessage); + if (!context) + { + return; + } + Renderer11 *renderer11 = GetImplAs<Context11>(context)->getRenderer(); + renderer11->getDebugAnnotatorContext()->beginEvent(entryPoint, eventName, eventMessage); +} + +void DebugAnnotator11::endEvent(gl::Context *context, + const char *eventName, + angle::EntryPoint entryPoint) +{ + angle::LoggingAnnotator::endEvent(context, eventName, entryPoint); + if (!context) + { + return; + } + Renderer11 *renderer11 = GetImplAs<Context11>(context)->getRenderer(); + renderer11->getDebugAnnotatorContext()->endEvent(eventName, entryPoint); +} + +void DebugAnnotator11::setMarker(gl::Context *context, const char *markerName) +{ + angle::LoggingAnnotator::setMarker(context, markerName); + if (!context) + { + return; + } + Renderer11 *renderer11 = GetImplAs<Context11>(context)->getRenderer(); + renderer11->getDebugAnnotatorContext()->setMarker(markerName); +} + +bool DebugAnnotator11::getStatus(const gl::Context *context) +{ + if (!context) + { + return false; + } + Renderer11 *renderer11 = GetImplAs<Context11>(context)->getRenderer(); + return renderer11->getDebugAnnotatorContext()->getStatus(); +} + +// DebugAnnotatorContext11 implemenetation +DebugAnnotatorContext11::DebugAnnotatorContext11() = default; + +DebugAnnotatorContext11::~DebugAnnotatorContext11() = default; + +void DebugAnnotatorContext11::beginEvent(angle::EntryPoint entryPoint, + const char *eventName, + const char *eventMessage) +{ + if (loggingEnabledForThisThread()) + { + std::mbstate_t state = std::mbstate_t(); + std::mbsrtowcs(mWCharMessage, &eventMessage, kMaxMessageLength, &state); + mUserDefinedAnnotation->BeginEvent(mWCharMessage); + } +} + +void DebugAnnotatorContext11::endEvent(const char *eventName, angle::EntryPoint entryPoint) +{ + if (loggingEnabledForThisThread()) + { + mUserDefinedAnnotation->EndEvent(); + } +} + +void DebugAnnotatorContext11::setMarker(const char *markerName) +{ + if (loggingEnabledForThisThread()) + { + std::mbstate_t state = std::mbstate_t(); + std::mbsrtowcs(mWCharMessage, &markerName, kMaxMessageLength, &state); + mUserDefinedAnnotation->SetMarker(mWCharMessage); + } +} + +bool DebugAnnotatorContext11::getStatus() const +{ + if (loggingEnabledForThisThread()) + { + return !!(mUserDefinedAnnotation->GetStatus()); + } + + return false; +} + +bool DebugAnnotatorContext11::loggingEnabledForThisThread() const +{ + return mUserDefinedAnnotation != nullptr && + angle::GetCurrentThreadUniqueId() == mAnnotationThread; +} + +void DebugAnnotatorContext11::initialize(ID3D11DeviceContext *context) +{ +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + // ID3DUserDefinedAnnotation.GetStatus only works on Windows10 or greater. + // Returning true unconditionally from DebugAnnotatorContext11::getStatus() means + // writing out all compiled shaders to temporary files even if debugging + // tools are not attached. See rx::ShaderD3D::prepareSourceAndReturnOptions. + // If you want debug annotations, you must use Windows 10. + if (IsWindows10OrGreater()) +#endif + { + mAnnotationThread = angle::GetCurrentThreadUniqueId(); + mUserDefinedAnnotation.Attach( + d3d11::DynamicCastComObject<ID3DUserDefinedAnnotation>(context)); + } +} + +void DebugAnnotatorContext11::release() +{ + mUserDefinedAnnotation.Reset(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h new file mode 100644 index 0000000000..0356636762 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h @@ -0,0 +1,60 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DebugAnnotator11.h: D3D11 helpers for adding trace annotations. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_DEBUGANNOTATOR11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_DEBUGANNOTATOR11_H_ + +#include "libANGLE/LoggingAnnotator.h" + +namespace rx +{ + +// Note: To avoid any race conditions between threads, this class has no private data; +// DebugAnnotatorContext11 will be retrieved from Context11. +class DebugAnnotator11 : public angle::LoggingAnnotator +{ + public: + DebugAnnotator11(); + ~DebugAnnotator11() override; + void beginEvent(gl::Context *context, + angle::EntryPoint entryPoint, + const char *eventName, + const char *eventMessage) override; + void endEvent(gl::Context *context, + const char *eventName, + angle::EntryPoint entryPoint) override; + void setMarker(gl::Context *context, const char *markerName) override; + bool getStatus(const gl::Context *context) override; +}; + +class DebugAnnotatorContext11 +{ + public: + DebugAnnotatorContext11(); + ~DebugAnnotatorContext11(); + void initialize(ID3D11DeviceContext *context); + void release(); + void beginEvent(angle::EntryPoint entryPoint, const char *eventName, const char *eventMessage); + void endEvent(const char *eventName, angle::EntryPoint entryPoint); + void setMarker(const char *markerName); + bool getStatus() const; + + private: + bool loggingEnabledForThisThread() const; + + angle::ComPtr<ID3DUserDefinedAnnotation> mUserDefinedAnnotation; + static constexpr size_t kMaxMessageLength = 256; + wchar_t mWCharMessage[kMaxMessageLength]; + + // Only log annotations from the thread used to initialize the debug annotator + uint64_t mAnnotationThread; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_DEBUGANNOTATOR11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.cpp new file mode 100644 index 0000000000..ff2fc8056c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.cpp @@ -0,0 +1,209 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +#include "libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.h" + +#include "libANGLE/Context.h" +#include "libANGLE/Error.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace rx +{ +ExternalImageSiblingImpl11::ExternalImageSiblingImpl11(Renderer11 *renderer, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) + : mRenderer(renderer), mBuffer(buffer), mAttribs(attribs) +{} + +ExternalImageSiblingImpl11::~ExternalImageSiblingImpl11() {} + +egl::Error ExternalImageSiblingImpl11::initialize(const egl::Display *display) +{ + const angle::Format *angleFormat = nullptr; + ANGLE_TRY(mRenderer->getD3DTextureInfo(nullptr, static_cast<IUnknown *>(mBuffer), mAttribs, + &mWidth, &mHeight, &mSamples, &mFormat, &angleFormat, + &mArraySlice)); + ID3D11Texture2D *texture = + d3d11::DynamicCastComObject<ID3D11Texture2D>(static_cast<IUnknown *>(mBuffer)); + ASSERT(texture != nullptr); + // TextureHelper11 will release texture on destruction. + mTexture.set(texture, d3d11::Format::Get(angleFormat->glInternalFormat, + mRenderer->getRenderer11DeviceCaps())); + D3D11_TEXTURE2D_DESC textureDesc = {}; + mTexture.getDesc(&textureDesc); + + IDXGIResource *resource = d3d11::DynamicCastComObject<IDXGIResource>(mTexture.get()); + ASSERT(resource != nullptr); + DXGI_USAGE resourceUsage = 0; + resource->GetUsage(&resourceUsage); + SafeRelease(resource); + + mIsRenderable = (textureDesc.BindFlags & D3D11_BIND_RENDER_TARGET) && + (resourceUsage & DXGI_USAGE_RENDER_TARGET_OUTPUT) && + !(resourceUsage & DXGI_USAGE_READ_ONLY); + + mIsTexturable = (textureDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE) && + (resourceUsage & DXGI_USAGE_SHADER_INPUT); + + mIsTextureArray = (textureDesc.ArraySize > 1); + + return egl::NoError(); +} + +gl::Format ExternalImageSiblingImpl11::getFormat() const +{ + return mFormat; +} + +bool ExternalImageSiblingImpl11::isRenderable(const gl::Context *context) const +{ + return mIsRenderable; +} + +bool ExternalImageSiblingImpl11::isTexturable(const gl::Context *context) const +{ + return mIsTexturable; +} + +bool ExternalImageSiblingImpl11::isYUV() const +{ + return false; +} + +bool ExternalImageSiblingImpl11::hasProtectedContent() const +{ + return false; +} + +gl::Extents ExternalImageSiblingImpl11::getSize() const +{ + return gl::Extents(mWidth, mHeight, 1); +} + +size_t ExternalImageSiblingImpl11::getSamples() const +{ + return mSamples; +} + +angle::Result ExternalImageSiblingImpl11::getAttachmentRenderTarget( + const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) +{ + ANGLE_TRY(createRenderTarget(context)); + *rtOut = mRenderTarget.get(); + return angle::Result::Continue; +} + +angle::Result ExternalImageSiblingImpl11::initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) +{ + UNREACHABLE(); + return angle::Result::Stop; +} + +angle::Result ExternalImageSiblingImpl11::createRenderTarget(const gl::Context *context) +{ + if (mRenderTarget) + return angle::Result::Continue; + + Context11 *context11 = GetImplAs<Context11>(context); + const d3d11::Format &formatInfo = mTexture.getFormatSet(); + + d3d11::RenderTargetView rtv; + if (mIsRenderable) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = formatInfo.rtvFormat; + if (mIsTextureArray) + { + if (mSamples == 0) + { + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = 0; + rtvDesc.Texture2DArray.FirstArraySlice = mArraySlice; + rtvDesc.Texture2DArray.ArraySize = 1; + } + else + { + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY; + rtvDesc.Texture2DMSArray.FirstArraySlice = mArraySlice; + rtvDesc.Texture2DMSArray.ArraySize = 1; + } + } + else + { + if (mSamples == 0) + { + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtvDesc.Texture2D.MipSlice = 0; + } + else + { + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS; + } + } + + ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, mTexture.get(), &rtv)); + rtv.setInternalName("getAttachmentRenderTarget.RTV"); + } + + d3d11::SharedSRV srv; + if (mIsTexturable) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = formatInfo.srvFormat; + if (mIsTextureArray) + { + if (mSamples == 0) + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = 0; + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = mArraySlice; + srvDesc.Texture2DArray.ArraySize = 1; + } + else + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; + srvDesc.Texture2DArray.FirstArraySlice = mArraySlice; + srvDesc.Texture2DArray.ArraySize = 1; + } + } + else + { + if (mSamples == 0) + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = 0; + srvDesc.Texture2D.MipLevels = 1; + } + else + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; + } + } + + ANGLE_TRY(mRenderer->allocateResource(context11, srvDesc, mTexture.get(), &srv)); + srv.setInternalName("getAttachmentRenderTarget.SRV"); + } + d3d11::SharedSRV blitSrv = srv.makeCopy(); + + mRenderTarget = std::make_unique<TextureRenderTarget11>( + std::move(rtv), mTexture, std::move(srv), std::move(blitSrv), mFormat.info->internalFormat, + formatInfo, mWidth, mHeight, 1, mSamples); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.h new file mode 100644 index 0000000000..3c57120ba2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.h @@ -0,0 +1,70 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_EXTERNALIMAGESIBLINGIMPL11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_EXTERNALIMAGESIBLINGIMPL11_H_ + +#include "libANGLE/renderer/ImageImpl.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ + +class Renderer11; +class RenderTargetD3D; + +class ExternalImageSiblingImpl11 : public ExternalImageSiblingImpl +{ + public: + ExternalImageSiblingImpl11(Renderer11 *renderer, + EGLClientBuffer clientBuffer, + const egl::AttributeMap &attribs); + ~ExternalImageSiblingImpl11() override; + + // ExternalImageSiblingImpl interface + egl::Error initialize(const egl::Display *display) override; + gl::Format getFormat() const override; + bool isRenderable(const gl::Context *context) const override; + bool isTexturable(const gl::Context *context) const override; + bool isYUV() const override; + bool hasProtectedContent() const override; + gl::Extents getSize() const override; + size_t getSamples() const override; + + // FramebufferAttachmentObjectImpl interface + angle::Result getAttachmentRenderTarget(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex, + GLsizei samples, + FramebufferAttachmentRenderTarget **rtOut) override; + angle::Result initializeContents(const gl::Context *context, + GLenum binding, + const gl::ImageIndex &imageIndex) override; + + private: + angle::Result createRenderTarget(const gl::Context *context); + + Renderer11 *mRenderer; + EGLClientBuffer mBuffer; + egl::AttributeMap mAttribs; + + TextureHelper11 mTexture; + + gl::Format mFormat = gl::Format::Invalid(); + bool mIsRenderable = false; + bool mIsTexturable = false; + bool mIsTextureArray = false; + EGLint mWidth = 0; + EGLint mHeight = 0; + GLsizei mSamples = 0; + UINT mArraySlice = 0; + + std::unique_ptr<RenderTargetD3D> mRenderTarget; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_EXTERNALIMAGESIBLINGIMPL11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp new file mode 100644 index 0000000000..38a7331b00 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp @@ -0,0 +1,234 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Fence11.cpp: Defines the rx::FenceNV11 and rx::Sync11 classes which implement +// rx::FenceNVImpl and rx::SyncImpl. + +#include "libANGLE/renderer/d3d/d3d11/Fence11.h" + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +// +// Template helpers for set and test operations. +// + +template <class FenceClass> +angle::Result FenceSetHelper(const gl::Context *context, FenceClass *fence) +{ + if (!fence->mQuery) + { + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = D3D11_QUERY_EVENT; + queryDesc.MiscFlags = 0; + + Context11 *context11 = GetImplAs<Context11>(context); + HRESULT result = fence->mRenderer->getDevice()->CreateQuery(&queryDesc, &fence->mQuery); + ANGLE_TRY_HR(context11, result, "Failed to create event query"); + } + + fence->mRenderer->getDeviceContext()->End(fence->mQuery); + return angle::Result::Continue; +} + +template <class FenceClass> +angle::Result FenceTestHelper(const gl::Context *context, + FenceClass *fence, + bool flushCommandBuffer, + GLboolean *outFinished) +{ + ASSERT(fence->mQuery); + + UINT getDataFlags = (flushCommandBuffer ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH); + + Context11 *context11 = GetImplAs<Context11>(context); + HRESULT result = + fence->mRenderer->getDeviceContext()->GetData(fence->mQuery, nullptr, 0, getDataFlags); + ANGLE_TRY_HR(context11, result, "Failed to get query data"); + + ASSERT(result == S_OK || result == S_FALSE); + *outFinished = ((result == S_OK) ? GL_TRUE : GL_FALSE); + return angle::Result::Continue; +} + +// +// FenceNV11 +// + +FenceNV11::FenceNV11(Renderer11 *renderer) : FenceNVImpl(), mRenderer(renderer), mQuery(nullptr) {} + +FenceNV11::~FenceNV11() +{ + SafeRelease(mQuery); +} + +angle::Result FenceNV11::set(const gl::Context *context, GLenum condition) +{ + return FenceSetHelper(context, this); +} + +angle::Result FenceNV11::test(const gl::Context *context, GLboolean *outFinished) +{ + return FenceTestHelper(context, this, true, outFinished); +} + +angle::Result FenceNV11::finish(const gl::Context *context) +{ + GLboolean finished = GL_FALSE; + + int loopCount = 0; + while (finished != GL_TRUE) + { + loopCount++; + ANGLE_TRY(FenceTestHelper(context, this, true, &finished)); + + bool checkDeviceLost = (loopCount % kPollingD3DDeviceLostCheckFrequency) == 0; + if (checkDeviceLost && mRenderer->testDeviceLost()) + { + ANGLE_TRY_HR(GetImplAs<Context11>(context), DXGI_ERROR_DRIVER_INTERNAL_ERROR, + "Device was lost while querying result of an event query."); + } + + ScheduleYield(); + } + + return angle::Result::Continue; +} + +// +// Sync11 +// + +// Important note on accurate timers in Windows: +// +// QueryPerformanceCounter has a few major issues, including being 10x as expensive to call +// as timeGetTime on laptops and "jumping" during certain hardware events. +// +// See the comments at the top of the Chromium source file "chromium/src/base/time/time_win.cc" +// https://code.google.com/p/chromium/codesearch#chromium/src/base/time/time_win.cc +// +// We still opt to use QPC. In the present and moving forward, most newer systems will not suffer +// from buggy implementations. + +Sync11::Sync11(Renderer11 *renderer) : SyncImpl(), mRenderer(renderer), mQuery(nullptr) +{ + LARGE_INTEGER counterFreqency = {}; + BOOL success = QueryPerformanceFrequency(&counterFreqency); + ASSERT(success); + + mCounterFrequency = counterFreqency.QuadPart; +} + +Sync11::~Sync11() +{ + SafeRelease(mQuery); +} + +angle::Result Sync11::set(const gl::Context *context, GLenum condition, GLbitfield flags) +{ + ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0); + return FenceSetHelper(context, this); +} + +angle::Result Sync11::clientWait(const gl::Context *context, + GLbitfield flags, + GLuint64 timeout, + GLenum *outResult) +{ + ASSERT(outResult); + + bool flushCommandBuffer = ((flags & GL_SYNC_FLUSH_COMMANDS_BIT) != 0); + + *outResult = GL_WAIT_FAILED; + + GLboolean result = GL_FALSE; + ANGLE_TRY(FenceTestHelper(context, this, flushCommandBuffer, &result)); + + if (result == GL_TRUE) + { + *outResult = GL_ALREADY_SIGNALED; + return angle::Result::Continue; + } + + if (timeout == 0) + { + *outResult = GL_TIMEOUT_EXPIRED; + return angle::Result::Continue; + } + + LARGE_INTEGER currentCounter = {}; + BOOL success = QueryPerformanceCounter(¤tCounter); + ASSERT(success); + + LONGLONG timeoutInSeconds = static_cast<LONGLONG>(timeout / 1000000000ull); + LONGLONG endCounter = currentCounter.QuadPart + mCounterFrequency * timeoutInSeconds; + + // Extremely unlikely, but if mCounterFrequency is large enough, endCounter can wrap + if (endCounter < currentCounter.QuadPart) + { + endCounter = MAXLONGLONG; + } + + int loopCount = 0; + while (currentCounter.QuadPart < endCounter && !result) + { + loopCount++; + ScheduleYield(); + success = QueryPerformanceCounter(¤tCounter); + ASSERT(success); + + *outResult = GL_WAIT_FAILED; + + ANGLE_TRY(FenceTestHelper(context, this, flushCommandBuffer, &result)); + + bool checkDeviceLost = (loopCount % kPollingD3DDeviceLostCheckFrequency) == 0; + if (checkDeviceLost && mRenderer->testDeviceLost()) + { + *outResult = GL_WAIT_FAILED; + ANGLE_TRY_HR(GetImplAs<Context11>(context), DXGI_ERROR_DRIVER_INTERNAL_ERROR, + "Device was lost while querying result of an event query."); + } + } + + if (currentCounter.QuadPart >= endCounter) + { + *outResult = GL_TIMEOUT_EXPIRED; + } + else + { + *outResult = GL_CONDITION_SATISFIED; + } + + return angle::Result::Continue; +} + +angle::Result Sync11::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout) +{ + // Because our API is currently designed to be called from a single thread, we don't need to do + // extra work for a server-side fence. GPU commands issued after the fence is created will + // always be processed after the fence is signaled. + return angle::Result::Continue; +} + +angle::Result Sync11::getStatus(const gl::Context *context, GLint *outResult) +{ + GLboolean result = GL_FALSE; + + // The spec does not specify any way to report errors during the status test (e.g. device + // lost) so we report the fence is unblocked in case of error or signaled. + *outResult = GL_SIGNALED; + ANGLE_TRY(FenceTestHelper(context, this, false, &result)); + + *outResult = (result ? GL_SIGNALED : GL_UNSIGNALED); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.h new file mode 100644 index 0000000000..e35ff6b71c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Fence11.h @@ -0,0 +1,76 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Fence11.h: Defines the rx::FenceNV11 and rx::Sync11 classes which implement rx::FenceNVImpl +// and rx::SyncImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_FENCE11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_FENCE11_H_ + +#include "libANGLE/renderer/FenceNVImpl.h" +#include "libANGLE/renderer/SyncImpl.h" + +namespace rx +{ +class Renderer11; + +class FenceNV11 : public FenceNVImpl +{ + public: + explicit FenceNV11(Renderer11 *renderer); + ~FenceNV11() override; + + void onDestroy(const gl::Context *context) override {} + angle::Result set(const gl::Context *context, GLenum condition) override; + angle::Result test(const gl::Context *context, GLboolean *outFinished) override; + angle::Result finish(const gl::Context *context) override; + + private: + template <class T> + friend angle::Result FenceSetHelper(const gl::Context *context, T *fence); + template <class T> + friend angle::Result FenceTestHelper(const gl::Context *context, + T *fence, + bool flushCommandBuffer, + GLboolean *outFinished); + + Renderer11 *mRenderer; + ID3D11Query *mQuery; +}; + +class Sync11 : public SyncImpl +{ + public: + explicit Sync11(Renderer11 *renderer); + ~Sync11() override; + + angle::Result set(const gl::Context *context, GLenum condition, GLbitfield flags) override; + angle::Result clientWait(const gl::Context *context, + GLbitfield flags, + GLuint64 timeout, + GLenum *outResult) override; + angle::Result serverWait(const gl::Context *context, + GLbitfield flags, + GLuint64 timeout) override; + angle::Result getStatus(const gl::Context *context, GLint *outResult) override; + + private: + template <class T> + friend angle::Result FenceSetHelper(const gl::Context *context, T *fence); + template <class T> + friend angle::Result FenceTestHelper(const gl::Context *context, + T *fence, + bool flushCommandBuffer, + GLboolean *outFinished); + + Renderer11 *mRenderer; + ID3D11Query *mQuery; + LONGLONG mCounterFrequency; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_FENCE11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp new file mode 100644 index 0000000000..e6516ff521 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp @@ -0,0 +1,452 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Framebuffer11.cpp: Implements the Framebuffer11 class. + +#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" + +#include "common/bitset_utils.h" +#include "common/debug.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Texture.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Clear11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +using namespace angle; + +namespace rx +{ + +namespace +{ +angle::Result MarkAttachmentsDirty(const gl::Context *context, + const gl::FramebufferAttachment *attachment) +{ + if (attachment->type() == GL_TEXTURE) + { + gl::Texture *texture = attachment->getTexture(); + + TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureD3D->getNativeTexture(context, &texStorage)); + + if (texStorage) + { + TextureStorage11 *texStorage11 = GetAs<TextureStorage11>(texStorage); + ASSERT(texStorage11); + + texStorage11->markLevelDirty(attachment->mipLevel()); + } + } + + return angle::Result::Continue; +} + +UINT GetAttachmentLayer(const gl::FramebufferAttachment *attachment) +{ + if (attachment->type() == GL_TEXTURE && + attachment->getTexture()->getType() == gl::TextureType::_3D) + { + return attachment->layer(); + } + return 0; +} + +} // anonymous namespace + +Framebuffer11::Framebuffer11(const gl::FramebufferState &data, Renderer11 *renderer) + : FramebufferD3D(data, renderer), mRenderer(renderer) +{ + ASSERT(mRenderer != nullptr); +} + +Framebuffer11::~Framebuffer11() {} + +angle::Result Framebuffer11::markAttachmentsDirty(const gl::Context *context) const +{ + const auto &colorAttachments = mState.getColorAttachments(); + for (size_t drawBuffer : mState.getEnabledDrawBuffers()) + { + const gl::FramebufferAttachment &colorAttachment = colorAttachments[drawBuffer]; + ASSERT(colorAttachment.isAttached()); + ANGLE_TRY(MarkAttachmentsDirty(context, &colorAttachment)); + } + + const gl::FramebufferAttachment *dsAttachment = mState.getDepthOrStencilAttachment(); + if (dsAttachment) + { + ANGLE_TRY(MarkAttachmentsDirty(context, dsAttachment)); + } + + return angle::Result::Continue; +} + +angle::Result Framebuffer11::clearImpl(const gl::Context *context, + const ClearParameters &clearParams) +{ + Clear11 *clearer = mRenderer->getClearer(); + + const gl::FramebufferAttachment *colorAttachment = mState.getFirstColorAttachment(); + if (clearParams.scissorEnabled == true && colorAttachment != nullptr && + UsePresentPathFast(mRenderer, colorAttachment)) + { + // If the current framebuffer is using the default colorbuffer, and present path fast is + // active, and the scissor rect is enabled, then we should invert the scissor rect + // vertically + ClearParameters presentPathFastClearParams = clearParams; + gl::Extents framebufferSize = colorAttachment->getSize(); + presentPathFastClearParams.scissor.y = framebufferSize.height - + presentPathFastClearParams.scissor.y - + presentPathFastClearParams.scissor.height; + ANGLE_TRY(clearer->clearFramebuffer(context, presentPathFastClearParams, mState)); + } + else + { + ANGLE_TRY(clearer->clearFramebuffer(context, clearParams, mState)); + } + + ANGLE_TRY(markAttachmentsDirty(context)); + + return angle::Result::Continue; +} + +angle::Result Framebuffer11::invalidate(const gl::Context *context, + size_t count, + const GLenum *attachments) +{ + return invalidateBase(context, count, attachments, false); +} + +angle::Result Framebuffer11::discard(const gl::Context *context, + size_t count, + const GLenum *attachments) +{ + return invalidateBase(context, count, attachments, true); +} + +angle::Result Framebuffer11::invalidateBase(const gl::Context *context, + size_t count, + const GLenum *attachments, + bool useEXTBehavior) const +{ + ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported(); + + if (!deviceContext1) + { + // DiscardView() is only supported on ID3D11DeviceContext1 + return angle::Result::Continue; + } + + bool foundDepth = false; + bool foundStencil = false; + + for (size_t i = 0; i < count; ++i) + { + switch (attachments[i]) + { + // Handle depth and stencil attachments. Defer discarding until later. + case GL_DEPTH_STENCIL_ATTACHMENT: + foundDepth = true; + foundStencil = true; + break; + case GL_DEPTH_EXT: + case GL_DEPTH_ATTACHMENT: + foundDepth = true; + break; + case GL_STENCIL_EXT: + case GL_STENCIL_ATTACHMENT: + foundStencil = true; + break; + default: + { + // Handle color attachments + ASSERT((attachments[i] >= GL_COLOR_ATTACHMENT0 && + attachments[i] <= GL_COLOR_ATTACHMENT15) || + (attachments[i] == GL_COLOR)); + + size_t colorIndex = + (attachments[i] == GL_COLOR ? 0u : (attachments[i] - GL_COLOR_ATTACHMENT0)); + const gl::FramebufferAttachment *colorAttachment = + mState.getColorAttachment(colorIndex); + if (colorAttachment) + { + ANGLE_TRY(invalidateAttachment(context, colorAttachment)); + } + break; + } + } + } + + bool discardDepth = false; + bool discardStencil = false; + + // The D3D11 renderer uses the same view for depth and stencil buffers, so we must be careful. + if (useEXTBehavior) + { + // In the extension, if the app discards only one of the depth and stencil attachments, but + // those are backed by the same packed_depth_stencil buffer, then both images become + // undefined. + discardDepth = foundDepth; + + // Don't bother discarding the stencil buffer if the depth buffer will already do it + discardStencil = foundStencil && (!discardDepth || mState.getDepthAttachment() == nullptr); + } + else + { + // In ES 3.0.4, if a specified attachment has base internal format DEPTH_STENCIL but the + // attachments list does not include DEPTH_STENCIL_ATTACHMENT or both DEPTH_ATTACHMENT and + // STENCIL_ATTACHMENT, then only the specified portion of every pixel in the subregion of + // pixels of the DEPTH_STENCIL buffer may be invalidated, and the other portion must be + // preserved. + discardDepth = (foundDepth && foundStencil) || + (foundDepth && (mState.getStencilAttachment() == nullptr)); + discardStencil = (foundStencil && (mState.getDepthAttachment() == nullptr)); + } + + if (discardDepth && mState.getDepthAttachment()) + { + ANGLE_TRY(invalidateAttachment(context, mState.getDepthAttachment())); + } + + if (discardStencil && mState.getStencilAttachment()) + { + ANGLE_TRY(invalidateAttachment(context, mState.getStencilAttachment())); + } + + return angle::Result::Continue; +} + +angle::Result Framebuffer11::invalidateSub(const gl::Context *context, + size_t count, + const GLenum *attachments, + const gl::Rectangle &area) +{ + // A no-op implementation conforms to the spec, so don't call UNIMPLEMENTED() + return angle::Result::Continue; +} + +angle::Result Framebuffer11::invalidateAttachment(const gl::Context *context, + const gl::FramebufferAttachment *attachment) const +{ + ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported(); + ASSERT(deviceContext1); + ASSERT(attachment && attachment->isAttached()); + + RenderTarget11 *renderTarget = nullptr; + ANGLE_TRY(attachment->getRenderTarget(context, 0, &renderTarget)); + const auto &rtv = renderTarget->getRenderTargetView(); + + if (rtv.valid()) + { + deviceContext1->DiscardView(rtv.get()); + } + + return angle::Result::Continue; +} + +angle::Result Framebuffer11::readPixelsImpl(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + size_t outputPitch, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + uint8_t *pixels) +{ + const gl::FramebufferAttachment *readAttachment = mState.getReadPixelsAttachment(format); + ASSERT(readAttachment); + + if (packBuffer != nullptr) + { + Buffer11 *packBufferStorage = GetImplAs<Buffer11>(packBuffer); + const angle::Format &angleFormat = GetFormatFromFormatType(format, type); + PackPixelsParams packParams(area, angleFormat, static_cast<GLuint>(outputPitch), + pack.reverseRowOrder, packBuffer, + reinterpret_cast<ptrdiff_t>(pixels)); + + return packBufferStorage->packPixels(context, *readAttachment, packParams); + } + + return mRenderer->readFromAttachment(context, *readAttachment, area, format, type, + static_cast<GLuint>(outputPitch), pack, pixels); +} + +angle::Result Framebuffer11::blitImpl(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + const gl::Rectangle *scissor, + bool blitRenderTarget, + bool blitDepth, + bool blitStencil, + GLenum filter, + const gl::Framebuffer *sourceFramebuffer) +{ + if (blitRenderTarget) + { + const gl::FramebufferAttachment *readBuffer = sourceFramebuffer->getReadColorAttachment(); + ASSERT(readBuffer); + + RenderTargetD3D *readRenderTarget = nullptr; + ANGLE_TRY(readBuffer->getRenderTarget(context, 0, &readRenderTarget)); + ASSERT(readRenderTarget); + + const auto &colorAttachments = mState.getColorAttachments(); + const auto &drawBufferStates = mState.getDrawBufferStates(); + UINT readLayer = GetAttachmentLayer(readBuffer); + + for (size_t colorAttachment = 0; colorAttachment < colorAttachments.size(); + colorAttachment++) + { + const gl::FramebufferAttachment &drawBuffer = colorAttachments[colorAttachment]; + + if (drawBuffer.isAttached() && drawBufferStates[colorAttachment] != GL_NONE) + { + RenderTargetD3D *drawRenderTarget = nullptr; + ANGLE_TRY(drawBuffer.getRenderTarget( + context, drawBuffer.getRenderToTextureSamples(), &drawRenderTarget)); + ASSERT(drawRenderTarget); + + const bool invertColorSource = UsePresentPathFast(mRenderer, readBuffer); + gl::Rectangle actualSourceArea = sourceArea; + if (invertColorSource) + { + RenderTarget11 *readRenderTarget11 = GetAs<RenderTarget11>(readRenderTarget); + actualSourceArea.y = readRenderTarget11->getHeight() - sourceArea.y; + actualSourceArea.height = -sourceArea.height; + } + + const bool invertColorDest = UsePresentPathFast(mRenderer, &drawBuffer); + gl::Rectangle actualDestArea = destArea; + UINT drawLayer = GetAttachmentLayer(&drawBuffer); + + const auto &surfaceTextureOffset = mState.getSurfaceTextureOffset(); + actualDestArea.x = actualDestArea.x + surfaceTextureOffset.x; + actualDestArea.y = actualDestArea.y + surfaceTextureOffset.y; + + if (invertColorDest) + { + RenderTarget11 *drawRenderTarget11 = GetAs<RenderTarget11>(drawRenderTarget); + actualDestArea.y = drawRenderTarget11->getHeight() - destArea.y; + actualDestArea.height = -destArea.height; + } + + ANGLE_TRY(mRenderer->blitRenderbufferRect(context, actualSourceArea, actualDestArea, + readLayer, drawLayer, readRenderTarget, + drawRenderTarget, filter, scissor, + blitRenderTarget, false, false)); + } + } + } + + if (blitDepth || blitStencil) + { + const gl::FramebufferAttachment *readBuffer = + sourceFramebuffer->getDepthOrStencilAttachment(); + ASSERT(readBuffer); + RenderTargetD3D *readRenderTarget = nullptr; + ANGLE_TRY(readBuffer->getRenderTarget(context, 0, &readRenderTarget)); + ASSERT(readRenderTarget); + + const bool invertSource = UsePresentPathFast(mRenderer, readBuffer); + gl::Rectangle actualSourceArea = sourceArea; + if (invertSource) + { + RenderTarget11 *readRenderTarget11 = GetAs<RenderTarget11>(readRenderTarget); + actualSourceArea.y = readRenderTarget11->getHeight() - sourceArea.y; + actualSourceArea.height = -sourceArea.height; + } + + const gl::FramebufferAttachment *drawBuffer = mState.getDepthOrStencilAttachment(); + ASSERT(drawBuffer); + RenderTargetD3D *drawRenderTarget = nullptr; + ANGLE_TRY(drawBuffer->getRenderTarget(context, drawBuffer->getRenderToTextureSamples(), + &drawRenderTarget)); + ASSERT(drawRenderTarget); + + bool invertDest = UsePresentPathFast(mRenderer, drawBuffer); + gl::Rectangle actualDestArea = destArea; + if (invertDest) + { + RenderTarget11 *drawRenderTarget11 = GetAs<RenderTarget11>(drawRenderTarget); + actualDestArea.y = drawRenderTarget11->getHeight() - destArea.y; + actualDestArea.height = -destArea.height; + } + + ANGLE_TRY(mRenderer->blitRenderbufferRect(context, actualSourceArea, actualDestArea, 0, 0, + readRenderTarget, drawRenderTarget, filter, + scissor, false, blitDepth, blitStencil)); + } + + ANGLE_TRY(markAttachmentsDirty(context)); + return angle::Result::Continue; +} + +const gl::InternalFormat &Framebuffer11::getImplementationColorReadFormat( + const gl::Context *context) const +{ + Context11 *context11 = GetImplAs<Context11>(context); + const Renderer11DeviceCaps &caps = context11->getRenderer()->getRenderer11DeviceCaps(); + GLenum sizedFormat = mState.getReadAttachment()->getFormat().info->sizedInternalFormat; + const angle::Format &angleFormat = d3d11::Format::Get(sizedFormat, caps).format(); + return gl::GetSizedInternalFormatInfo(angleFormat.fboImplementationInternalFormat); +} + +angle::Result Framebuffer11::syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) +{ + ANGLE_TRY(mRenderTargetCache.update(context, mState, dirtyBits)); + ANGLE_TRY(FramebufferD3D::syncState(context, binding, dirtyBits, command)); + + // Call this last to allow the state manager to take advantage of the cached render targets. + mRenderer->getStateManager()->invalidateRenderTarget(); + + // Call this to syncViewport for framebuffer default parameters. + if (mState.getDefaultWidth() != 0 || mState.getDefaultHeight() != 0) + { + mRenderer->getStateManager()->invalidateViewport(context); + } + + return angle::Result::Continue; +} + +angle::Result Framebuffer11::getSamplePosition(const gl::Context *context, + size_t index, + GLfloat *xy) const +{ + const gl::FramebufferAttachment *attachment = mState.getFirstNonNullAttachment(); + ASSERT(attachment); + GLsizei sampleCount = attachment->getSamples(); + + rx::GetSamplePosition(sampleCount, index, xy); + return angle::Result::Continue; +} + +RenderTarget11 *Framebuffer11::getFirstRenderTarget() const +{ + for (auto *renderTarget : mRenderTargetCache.getColors()) + { + if (renderTarget) + { + return renderTarget; + } + } + + return mRenderTargetCache.getDepthStencil(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h new file mode 100644 index 0000000000..34cfdbd30e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h @@ -0,0 +1,100 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Framebuffer11.h: Defines the Framebuffer11 class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_FRAMBUFFER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_FRAMBUFFER11_H_ + +#include "libANGLE/Observer.h" +#include "libANGLE/renderer/RenderTargetCache.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ +class Renderer11; + +class Framebuffer11 : public FramebufferD3D +{ + public: + Framebuffer11(const gl::FramebufferState &data, Renderer11 *renderer); + ~Framebuffer11() override; + + angle::Result discard(const gl::Context *context, + size_t count, + const GLenum *attachments) override; + angle::Result invalidate(const gl::Context *context, + size_t count, + const GLenum *attachments) override; + angle::Result invalidateSub(const gl::Context *context, + size_t count, + const GLenum *attachments, + const gl::Rectangle &area) override; + + // Invalidate the cached swizzles of all bound texture attachments. + angle::Result markAttachmentsDirty(const gl::Context *context) const; + + angle::Result syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) override; + + const gl::AttachmentArray<RenderTarget11 *> &getCachedColorRenderTargets() const + { + return mRenderTargetCache.getColors(); + } + const RenderTarget11 *getCachedDepthStencilRenderTarget() const + { + return mRenderTargetCache.getDepthStencil(); + } + + RenderTarget11 *getFirstRenderTarget() const; + + angle::Result getSamplePosition(const gl::Context *context, + size_t index, + GLfloat *xy) const override; + + const gl::InternalFormat &getImplementationColorReadFormat( + const gl::Context *context) const override; + + private: + angle::Result clearImpl(const gl::Context *context, + const ClearParameters &clearParams) override; + + angle::Result readPixelsImpl(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + size_t outputPitch, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + uint8_t *pixels) override; + + angle::Result blitImpl(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + const gl::Rectangle *scissor, + bool blitRenderTarget, + bool blitDepth, + bool blitStencil, + GLenum filter, + const gl::Framebuffer *sourceFramebuffer) override; + + angle::Result invalidateBase(const gl::Context *context, + size_t count, + const GLenum *attachments, + bool useEXTBehavior) const; + angle::Result invalidateAttachment(const gl::Context *context, + const gl::FramebufferAttachment *attachment) const; + + Renderer11 *const mRenderer; + RenderTargetCache<RenderTarget11> mRenderTargetCache; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_FRAMBUFFER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.cpp new file mode 100644 index 0000000000..2e6558b304 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.cpp @@ -0,0 +1,676 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Image11.h: Implements the rx::Image11 class, which acts as the interface to +// the actual underlying resources of a Texture + +#include "libANGLE/renderer/d3d/d3d11/Image11.h" + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace rx +{ + +Image11::Image11(Renderer11 *renderer) + : mRenderer(renderer), + mDXGIFormat(DXGI_FORMAT_UNKNOWN), + mStagingTexture(), + mStagingSubresource(0), + mRecoverFromStorage(false), + mAssociatedStorage(nullptr), + mAssociatedImageIndex(), + mRecoveredFromStorageCount(0) +{} + +Image11::~Image11() +{ + disassociateStorage(); + releaseStagingTexture(); +} + +// static +angle::Result Image11::GenerateMipmap(const gl::Context *context, + Image11 *dest, + Image11 *src, + const Renderer11DeviceCaps &rendererCaps) +{ + ASSERT(src->getDXGIFormat() == dest->getDXGIFormat()); + ASSERT(src->getWidth() == 1 || src->getWidth() / 2 == dest->getWidth()); + ASSERT(src->getHeight() == 1 || src->getHeight() / 2 == dest->getHeight()); + + D3D11_MAPPED_SUBRESOURCE destMapped; + ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped)); + d3d11::ScopedUnmapper<Image11> destRAII(dest); + + D3D11_MAPPED_SUBRESOURCE srcMapped; + ANGLE_TRY(src->map(context, D3D11_MAP_READ, &srcMapped)); + d3d11::ScopedUnmapper<Image11> srcRAII(src); + + const uint8_t *sourceData = static_cast<const uint8_t *>(srcMapped.pData); + uint8_t *destData = static_cast<uint8_t *>(destMapped.pData); + + auto mipGenerationFunction = + d3d11::Format::Get(src->getInternalFormat(), rendererCaps).format().mipGenerationFunction; + mipGenerationFunction(src->getWidth(), src->getHeight(), src->getDepth(), sourceData, + srcMapped.RowPitch, srcMapped.DepthPitch, destData, destMapped.RowPitch, + destMapped.DepthPitch); + + dest->markDirty(); + + return angle::Result::Continue; +} + +// static +angle::Result Image11::CopyImage(const gl::Context *context, + Image11 *dest, + Image11 *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const Renderer11DeviceCaps &rendererCaps) +{ + D3D11_MAPPED_SUBRESOURCE destMapped; + ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped)); + d3d11::ScopedUnmapper<Image11> destRAII(dest); + + D3D11_MAPPED_SUBRESOURCE srcMapped; + ANGLE_TRY(source->map(context, D3D11_MAP_READ, &srcMapped)); + d3d11::ScopedUnmapper<Image11> sourceRAII(source); + + const auto &sourceFormat = + d3d11::Format::Get(source->getInternalFormat(), rendererCaps).format(); + GLuint sourcePixelBytes = + gl::GetSizedInternalFormatInfo(sourceFormat.fboImplementationInternalFormat).pixelBytes; + + GLenum destUnsizedFormat = gl::GetUnsizedFormat(dest->getInternalFormat()); + const auto &destFormat = d3d11::Format::Get(dest->getInternalFormat(), rendererCaps).format(); + const auto &destFormatInfo = + gl::GetSizedInternalFormatInfo(destFormat.fboImplementationInternalFormat); + GLuint destPixelBytes = destFormatInfo.pixelBytes; + + const uint8_t *sourceData = static_cast<const uint8_t *>(srcMapped.pData) + + sourceBox.x * sourcePixelBytes + sourceBox.y * srcMapped.RowPitch + + sourceBox.z * srcMapped.DepthPitch; + uint8_t *destData = static_cast<uint8_t *>(destMapped.pData) + destOffset.x * destPixelBytes + + destOffset.y * destMapped.RowPitch + destOffset.z * destMapped.DepthPitch; + + CopyImageCHROMIUM(sourceData, srcMapped.RowPitch, sourcePixelBytes, srcMapped.DepthPitch, + sourceFormat.pixelReadFunction, destData, destMapped.RowPitch, destPixelBytes, + destMapped.DepthPitch, destFormat.pixelWriteFunction, destUnsizedFormat, + destFormatInfo.componentType, sourceBox.width, sourceBox.height, + sourceBox.depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + + dest->markDirty(); + + return angle::Result::Continue; +} + +bool Image11::isDirty() const +{ + // If mDirty is true AND mStagingTexture doesn't exist AND mStagingTexture doesn't need to be + // recovered from TextureStorage AND the texture doesn't require init data (i.e. a blank new + // texture will suffice) AND robust resource initialization is not enabled then isDirty should + // still return false. + if (mDirty && !mStagingTexture.valid() && !mRecoverFromStorage) + { + const Renderer11DeviceCaps &deviceCaps = mRenderer->getRenderer11DeviceCaps(); + const auto &formatInfo = d3d11::Format::Get(mInternalFormat, deviceCaps); + if (formatInfo.dataInitializerFunction == nullptr) + { + return false; + } + } + + return mDirty; +} + +angle::Result Image11::copyToStorage(const gl::Context *context, + TextureStorage *storage, + const gl::ImageIndex &index, + const gl::Box ®ion) +{ + TextureStorage11 *storage11 = GetAs<TextureStorage11>(storage); + + // If an app's behavior results in an Image11 copying its data to/from to a TextureStorage + // multiple times, then we should just keep the staging texture around to prevent the copying + // from impacting perf. We allow the Image11 to copy its data to/from TextureStorage once. This + // accounts for an app making a late call to glGenerateMipmap. + bool attemptToReleaseStagingTexture = (mRecoveredFromStorageCount < 2); + + if (attemptToReleaseStagingTexture) + { + // If another image is relying on this Storage for its data, then we must let it recover its + // data before we overwrite it. + ANGLE_TRY(storage11->releaseAssociatedImage(context, index, this)); + } + + const TextureHelper11 *stagingTexture = nullptr; + unsigned int stagingSubresourceIndex = 0; + ANGLE_TRY(getStagingTexture(context, &stagingTexture, &stagingSubresourceIndex)); + ANGLE_TRY(storage11->updateSubresourceLevel(context, *stagingTexture, stagingSubresourceIndex, + index, region)); + + // Once the image data has been copied into the Storage, we can release it locally. + if (attemptToReleaseStagingTexture) + { + storage11->associateImage(this, index); + releaseStagingTexture(); + mRecoverFromStorage = true; + mAssociatedStorage = storage11; + mAssociatedImageIndex = index; + } + + return angle::Result::Continue; +} + +void Image11::verifyAssociatedStorageValid(TextureStorage11 *textureStorageEXT) const +{ + ASSERT(mAssociatedStorage == textureStorageEXT); +} + +angle::Result Image11::recoverFromAssociatedStorage(const gl::Context *context) +{ + if (mRecoverFromStorage) + { + ANGLE_TRY(createStagingTexture(context)); + + mAssociatedStorage->verifyAssociatedImageValid(mAssociatedImageIndex, this); + + // CopySubResource from the Storage to the Staging texture + gl::Box region(0, 0, 0, mWidth, mHeight, mDepth); + ANGLE_TRY(mAssociatedStorage->copySubresourceLevel( + context, mStagingTexture, mStagingSubresource, mAssociatedImageIndex, region)); + mRecoveredFromStorageCount += 1; + + // Reset all the recovery parameters, even if the texture storage association is broken. + disassociateStorage(); + + markDirty(); + } + + return angle::Result::Continue; +} + +void Image11::disassociateStorage() +{ + if (mRecoverFromStorage) + { + // Make the texturestorage release the Image11 too + mAssociatedStorage->disassociateImage(mAssociatedImageIndex, this); + + mRecoverFromStorage = false; + mAssociatedStorage = nullptr; + mAssociatedImageIndex = gl::ImageIndex(); + } +} + +bool Image11::redefine(gl::TextureType type, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + if (mWidth != size.width || mHeight != size.height || mDepth != size.depth || + mInternalFormat != internalformat || forceRelease) + { + // End the association with the TextureStorage, since that data will be out of date. + // Also reset mRecoveredFromStorageCount since this Image is getting completely redefined. + disassociateStorage(); + mRecoveredFromStorageCount = 0; + + mWidth = size.width; + mHeight = size.height; + mDepth = size.depth; + mInternalFormat = internalformat; + mType = type; + + // compute the d3d format that will be used + const d3d11::Format &formatInfo = + d3d11::Format::Get(internalformat, mRenderer->getRenderer11DeviceCaps()); + mDXGIFormat = formatInfo.texFormat; + mRenderable = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); + + releaseStagingTexture(); + mDirty = (formatInfo.dataInitializerFunction != nullptr); + + return true; + } + + return false; +} + +DXGI_FORMAT Image11::getDXGIFormat() const +{ + // this should only happen if the image hasn't been redefined first + // which would be a bug by the caller + ASSERT(mDXGIFormat != DXGI_FORMAT_UNKNOWN); + + return mDXGIFormat; +} + +// Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as +// format/type at input +// into the target pixel rectangle. +angle::Result Image11::loadData(const gl::Context *context, + const gl::Box &area, + const gl::PixelUnpackState &unpack, + GLenum type, + const void *input, + bool applySkipImages) +{ + Context11 *context11 = GetImplAs<Context11>(context); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat); + GLuint inputRowPitch = 0; + ANGLE_CHECK_GL_MATH(context11, formatInfo.computeRowPitch(type, area.width, unpack.alignment, + unpack.rowLength, &inputRowPitch)); + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH(context11, formatInfo.computeDepthPitch(area.height, unpack.imageHeight, + inputRowPitch, &inputDepthPitch)); + GLuint inputSkipBytes = 0; + ANGLE_CHECK_GL_MATH(context11, + formatInfo.computeSkipBytes(type, inputRowPitch, inputDepthPitch, unpack, + applySkipImages, &inputSkipBytes)); + + const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat); + GLuint outputPixelSize = dxgiFormatInfo.pixelBytes; + + const d3d11::Format &d3dFormatInfo = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + LoadImageFunction loadFunction = d3dFormatInfo.getLoadFunctions()(type).loadFunction; + + D3D11_MAPPED_SUBRESOURCE mappedImage; + ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage)); + + uint8_t *offsetMappedData = (static_cast<uint8_t *>(mappedImage.pData) + + (area.y * mappedImage.RowPitch + area.x * outputPixelSize + + area.z * mappedImage.DepthPitch)); + loadFunction(area.width, area.height, area.depth, + static_cast<const uint8_t *>(input) + inputSkipBytes, inputRowPitch, + inputDepthPitch, offsetMappedData, mappedImage.RowPitch, mappedImage.DepthPitch); + + unmap(); + + return angle::Result::Continue; +} + +angle::Result Image11::loadCompressedData(const gl::Context *context, + const gl::Box &area, + const void *input) +{ + Context11 *context11 = GetImplAs<Context11>(context); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat); + GLuint inputRowPitch = 0; + ANGLE_CHECK_GL_MATH( + context11, formatInfo.computeRowPitch(GL_UNSIGNED_BYTE, area.width, 1, 0, &inputRowPitch)); + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH( + context11, formatInfo.computeDepthPitch(area.height, 0, inputRowPitch, &inputDepthPitch)); + + const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat); + GLuint outputPixelSize = dxgiFormatInfo.pixelBytes; + GLuint outputBlockWidth = dxgiFormatInfo.blockWidth; + GLuint outputBlockHeight = dxgiFormatInfo.blockHeight; + + ASSERT(area.x % outputBlockWidth == 0); + ASSERT(area.y % outputBlockHeight == 0); + + const d3d11::Format &d3dFormatInfo = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + LoadImageFunction loadFunction = + d3dFormatInfo.getLoadFunctions()(GL_UNSIGNED_BYTE).loadFunction; + + D3D11_MAPPED_SUBRESOURCE mappedImage; + ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage)); + + uint8_t *offsetMappedData = + static_cast<uint8_t *>(mappedImage.pData) + + ((area.y / outputBlockHeight) * mappedImage.RowPitch + + (area.x / outputBlockWidth) * outputPixelSize + area.z * mappedImage.DepthPitch); + + loadFunction(area.width, area.height, area.depth, static_cast<const uint8_t *>(input), + inputRowPitch, inputDepthPitch, offsetMappedData, mappedImage.RowPitch, + mappedImage.DepthPitch); + + unmap(); + + return angle::Result::Continue; +} + +angle::Result Image11::copyFromTexStorage(const gl::Context *context, + const gl::ImageIndex &imageIndex, + TextureStorage *source) +{ + TextureStorage11 *storage11 = GetAs<TextureStorage11>(source); + + const TextureHelper11 *textureHelper = nullptr; + ANGLE_TRY(storage11->getResource(context, &textureHelper)); + + UINT subresourceIndex = 0; + ANGLE_TRY(storage11->getSubresourceIndex(context, imageIndex, &subresourceIndex)); + + gl::Box sourceBox(0, 0, 0, mWidth, mHeight, mDepth); + return copyWithoutConversion(context, gl::Offset(), sourceBox, *textureHelper, + subresourceIndex); +} + +angle::Result Image11::copyFromFramebuffer(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + const gl::Framebuffer *sourceFBO) +{ + const gl::FramebufferAttachment *srcAttachment = sourceFBO->getReadColorAttachment(); + ASSERT(srcAttachment); + + GLenum sourceInternalFormat = srcAttachment->getFormat().info->sizedInternalFormat; + const auto &d3d11Format = + d3d11::Format::Get(sourceInternalFormat, mRenderer->getRenderer11DeviceCaps()); + + if (d3d11Format.texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat) + { + RenderTarget11 *rt11 = nullptr; + ANGLE_TRY(srcAttachment->getRenderTarget(context, 0, &rt11)); + ASSERT(rt11->getTexture().get()); + + TextureHelper11 textureHelper = rt11->getTexture(); + unsigned int sourceSubResource = rt11->getSubresourceIndex(); + + gl::Box sourceBox(sourceArea.x, sourceArea.y, 0, sourceArea.width, sourceArea.height, 1); + return copyWithoutConversion(context, destOffset, sourceBox, textureHelper, + sourceSubResource); + } + + // This format requires conversion, so we must copy the texture to staging and manually convert + // via readPixels + D3D11_MAPPED_SUBRESOURCE mappedImage; + ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage)); + + // determine the offset coordinate into the destination buffer + const auto &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat); + GLsizei rowOffset = dxgiFormatInfo.pixelBytes * destOffset.x; + + uint8_t *dataOffset = static_cast<uint8_t *>(mappedImage.pData) + + mappedImage.RowPitch * destOffset.y + rowOffset + + destOffset.z * mappedImage.DepthPitch; + + const gl::InternalFormat &destFormatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat); + const auto &destD3D11Format = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + + auto loadFunction = destD3D11Format.getLoadFunctions()(destFormatInfo.type); + angle::Result result = angle::Result::Continue; + if (loadFunction.requiresConversion) + { + size_t bufferSize = destFormatInfo.pixelBytes * sourceArea.width * sourceArea.height; + angle::MemoryBuffer *memoryBuffer = nullptr; + result = mRenderer->getScratchMemoryBuffer(GetImplAs<Context11>(context), bufferSize, + &memoryBuffer); + + if (result == angle::Result::Continue) + { + GLuint memoryBufferRowPitch = destFormatInfo.pixelBytes * sourceArea.width; + + result = mRenderer->readFromAttachment( + context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type, + memoryBufferRowPitch, gl::PixelPackState(), memoryBuffer->data()); + + loadFunction.loadFunction(sourceArea.width, sourceArea.height, 1, memoryBuffer->data(), + memoryBufferRowPitch, 0, dataOffset, mappedImage.RowPitch, + mappedImage.DepthPitch); + } + } + else + { + result = mRenderer->readFromAttachment( + context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type, + mappedImage.RowPitch, gl::PixelPackState(), dataOffset); + } + + unmap(); + mDirty = true; + + return result; +} + +angle::Result Image11::copyWithoutConversion(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Box &sourceArea, + const TextureHelper11 &textureHelper, + UINT sourceSubResource) +{ + // No conversion needed-- use copyback fastpath + const TextureHelper11 *stagingTexture = nullptr; + unsigned int stagingSubresourceIndex = 0; + ANGLE_TRY(getStagingTexture(context, &stagingTexture, &stagingSubresourceIndex)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + const gl::Extents &extents = textureHelper.getExtents(); + + D3D11_BOX srcBox; + srcBox.left = sourceArea.x; + srcBox.right = sourceArea.x + sourceArea.width; + srcBox.top = sourceArea.y; + srcBox.bottom = sourceArea.y + sourceArea.height; + srcBox.front = sourceArea.z; + srcBox.back = sourceArea.z + sourceArea.depth; + + if (textureHelper.is2D() && textureHelper.getSampleCount() > 1) + { + D3D11_TEXTURE2D_DESC resolveDesc; + resolveDesc.Width = extents.width; + resolveDesc.Height = extents.height; + resolveDesc.MipLevels = 1; + resolveDesc.ArraySize = 1; + resolveDesc.Format = textureHelper.getFormat(); + resolveDesc.SampleDesc.Count = 1; + resolveDesc.SampleDesc.Quality = 0; + resolveDesc.Usage = D3D11_USAGE_DEFAULT; + resolveDesc.BindFlags = 0; + resolveDesc.CPUAccessFlags = 0; + resolveDesc.MiscFlags = 0; + + d3d11::Texture2D resolveTex; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), resolveDesc, &resolveTex)); + + deviceContext->ResolveSubresource(resolveTex.get(), 0, textureHelper.get(), + sourceSubResource, textureHelper.getFormat()); + + deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex, + destOffset.x, destOffset.y, destOffset.z, + resolveTex.get(), 0, &srcBox); + } + else + { + deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex, + destOffset.x, destOffset.y, destOffset.z, + textureHelper.get(), sourceSubResource, &srcBox); + } + + mDirty = true; + return angle::Result::Continue; +} + +angle::Result Image11::getStagingTexture(const gl::Context *context, + const TextureHelper11 **outStagingTexture, + unsigned int *outSubresourceIndex) +{ + ANGLE_TRY(createStagingTexture(context)); + + *outStagingTexture = &mStagingTexture; + *outSubresourceIndex = mStagingSubresource; + return angle::Result::Continue; +} + +void Image11::releaseStagingTexture() +{ + mStagingTexture.reset(); + mStagingTextureSubresourceVerifier.reset(); +} + +angle::Result Image11::createStagingTexture(const gl::Context *context) +{ + if (mStagingTexture.valid()) + { + return angle::Result::Continue; + } + + ASSERT(mWidth > 0 && mHeight > 0 && mDepth > 0); + + const DXGI_FORMAT dxgiFormat = getDXGIFormat(); + const auto &formatInfo = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + + int lodOffset = 1; + GLsizei width = mWidth; + GLsizei height = mHeight; + + // adjust size if needed for compressed textures + d3d11::MakeValidSize(false, dxgiFormat, &width, &height, &lodOffset); + + Context11 *context11 = GetImplAs<Context11>(context); + + switch (mType) + { + case gl::TextureType::_3D: + { + D3D11_TEXTURE3D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.Depth = mDepth; + desc.MipLevels = lodOffset + 1; + desc.Format = dxgiFormat; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + + if (formatInfo.dataInitializerFunction != nullptr) + { + gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> initialData; + ANGLE_TRY(d3d11::GenerateInitialTextureData( + context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height, + mDepth, lodOffset + 1, &initialData)); + + ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo, + initialData.data(), &mStagingTexture)); + } + else + { + ANGLE_TRY( + mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture)); + } + + mStagingTexture.setInternalName("Image11::StagingTexture3D"); + mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1); + mStagingTextureSubresourceVerifier.setDesc(desc); + } + break; + + case gl::TextureType::_2D: + case gl::TextureType::_2DArray: + case gl::TextureType::CubeMap: + { + D3D11_TEXTURE2D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.MipLevels = lodOffset + 1; + desc.ArraySize = 1; + desc.Format = dxgiFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + + if (formatInfo.dataInitializerFunction != nullptr) + { + gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> initialData; + ANGLE_TRY(d3d11::GenerateInitialTextureData( + context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height, + 1, lodOffset + 1, &initialData)); + + ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo, + initialData.data(), &mStagingTexture)); + } + else + { + ANGLE_TRY( + mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture)); + } + + mStagingTexture.setInternalName("Image11::StagingTexture2D"); + mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1); + mStagingTextureSubresourceVerifier.setDesc(desc); + } + break; + + default: + UNREACHABLE(); + } + + mDirty = false; + return angle::Result::Continue; +} + +angle::Result Image11::map(const gl::Context *context, + D3D11_MAP mapType, + D3D11_MAPPED_SUBRESOURCE *map) +{ + // We must recover from the TextureStorage if necessary, even for D3D11_MAP_WRITE. + ANGLE_TRY(recoverFromAssociatedStorage(context)); + + const TextureHelper11 *stagingTexture = nullptr; + unsigned int subresourceIndex = 0; + ANGLE_TRY(getStagingTexture(context, &stagingTexture, &subresourceIndex)); + + ASSERT(stagingTexture && stagingTexture->valid()); + + ANGLE_TRY( + mRenderer->mapResource(context, stagingTexture->get(), subresourceIndex, mapType, 0, map)); + + if (!mStagingTextureSubresourceVerifier.wrap(mapType, map)) + { + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->Unmap(mStagingTexture.get(), mStagingSubresource); + Context11 *context11 = GetImplAs<Context11>(context); + context11->handleError(GL_OUT_OF_MEMORY, + "Failed to allocate staging texture mapping verifier buffer.", + __FILE__, ANGLE_FUNCTION, __LINE__); + return angle::Result::Stop; + } + + mDirty = true; + + return angle::Result::Continue; +} + +void Image11::unmap() +{ + if (mStagingTexture.valid()) + { + mStagingTextureSubresourceVerifier.unwrap(); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->Unmap(mStagingTexture.get(), mStagingSubresource); + } +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.h new file mode 100644 index 0000000000..661365240c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Image11.h @@ -0,0 +1,128 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Image11.h: Defines the rx::Image11 class, which acts as the interface to +// the actual underlying resources of a Texture + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_IMAGE11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_IMAGE11_H_ + +#include "common/debug.h" +#include "libANGLE/ImageIndex.h" +#include "libANGLE/renderer/d3d/ImageD3D.h" +#include "libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace gl +{ +class Framebuffer; +} + +namespace d3d11 +{ +template <typename T> +class ScopedUnmapper; +} // namespace d3d11 + +namespace rx +{ +class Renderer11; +class TextureHelper11; +class TextureStorage11; +struct Renderer11DeviceCaps; + +class Image11 : public ImageD3D +{ + public: + Image11(Renderer11 *renderer); + ~Image11() override; + + static angle::Result GenerateMipmap(const gl::Context *context, + Image11 *dest, + Image11 *src, + const Renderer11DeviceCaps &rendererCaps); + static angle::Result CopyImage(const gl::Context *context, + Image11 *dest, + Image11 *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, + const Renderer11DeviceCaps &rendererCaps); + + bool isDirty() const override; + + angle::Result copyToStorage(const gl::Context *context, + TextureStorage *storage, + const gl::ImageIndex &index, + const gl::Box ®ion) override; + + bool redefine(gl::TextureType type, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) override; + + DXGI_FORMAT getDXGIFormat() const; + + angle::Result loadData(const gl::Context *context, + const gl::Box &area, + const gl::PixelUnpackState &unpack, + GLenum type, + const void *input, + bool applySkipImages) override; + angle::Result loadCompressedData(const gl::Context *context, + const gl::Box &area, + const void *input) override; + + angle::Result copyFromTexStorage(const gl::Context *context, + const gl::ImageIndex &imageIndex, + TextureStorage *source) override; + angle::Result copyFromFramebuffer(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + const gl::Framebuffer *source) override; + + angle::Result recoverFromAssociatedStorage(const gl::Context *context); + void verifyAssociatedStorageValid(TextureStorage11 *textureStorageEXT) const; + void disassociateStorage(); + + angle::Result getStagingTexture(const gl::Context *context, + const TextureHelper11 **outStagingTexture, + unsigned int *outSubresourceIndex); + + protected: + template <typename T> + friend class d3d11::ScopedUnmapper; + angle::Result map(const gl::Context *context, D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map); + void unmap(); + + private: + angle::Result copyWithoutConversion(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Box &sourceArea, + const TextureHelper11 &textureHelper, + UINT sourceSubResource); + + angle::Result createStagingTexture(const gl::Context *context); + void releaseStagingTexture(); + + Renderer11 *mRenderer; + + DXGI_FORMAT mDXGIFormat; + TextureHelper11 mStagingTexture; + unsigned int mStagingSubresource; + MappedSubresourceVerifier11 mStagingTextureSubresourceVerifier; + + bool mRecoverFromStorage; + TextureStorage11 *mAssociatedStorage; + gl::ImageIndex mAssociatedImageIndex; + unsigned int mRecoveredFromStorageCount; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_IMAGE11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp new file mode 100644 index 0000000000..7630b341fa --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp @@ -0,0 +1,160 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexBuffer11.cpp: Defines the D3D11 IndexBuffer implementation. + +#include "libANGLE/renderer/d3d/d3d11/IndexBuffer11.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ + +IndexBuffer11::IndexBuffer11(Renderer11 *const renderer) + : mRenderer(renderer), + mBuffer(), + mBufferSize(0), + mIndexType(gl::DrawElementsType::InvalidEnum), + mDynamicUsage(false) +{} + +IndexBuffer11::~IndexBuffer11() {} + +angle::Result IndexBuffer11::initialize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType, + bool dynamic) +{ + mBuffer.reset(); + + updateSerial(); + + if (bufferSize > 0) + { + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = bufferSize; + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; + bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + bufferDesc.MiscFlags = 0; + bufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &mBuffer)); + + if (dynamic) + { + mBuffer.setInternalName("IndexBuffer11(dynamic)"); + } + else + { + mBuffer.setInternalName("IndexBuffer11(static)"); + } + } + + mBufferSize = bufferSize; + mIndexType = indexType; + mDynamicUsage = dynamic; + + return angle::Result::Continue; +} + +angle::Result IndexBuffer11::mapBuffer(const gl::Context *context, + unsigned int offset, + unsigned int size, + void **outMappedMemory) +{ + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_HR(context11, mBuffer.valid(), "Internal index buffer is not initialized.", + E_OUTOFMEMORY); + + // Check for integer overflows and out-out-bounds map requests + bool outOfBounds = (offset + size < offset || offset + size > mBufferSize); + ANGLE_CHECK_HR(context11, !outOfBounds, "Index buffer map range is not inside the buffer.", + E_OUTOFMEMORY); + + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mBuffer.get(), 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, + &mappedResource)); + + *outMappedMemory = static_cast<char *>(mappedResource.pData) + offset; + return angle::Result::Continue; +} + +angle::Result IndexBuffer11::unmapBuffer(const gl::Context *context) +{ + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_HR(context11, mBuffer.valid(), "Internal index buffer is not initialized.", + E_OUTOFMEMORY); + + ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext(); + dxContext->Unmap(mBuffer.get(), 0); + return angle::Result::Continue; +} + +gl::DrawElementsType IndexBuffer11::getIndexType() const +{ + return mIndexType; +} + +unsigned int IndexBuffer11::getBufferSize() const +{ + return mBufferSize; +} + +angle::Result IndexBuffer11::setSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) +{ + if (bufferSize > mBufferSize || indexType != mIndexType) + { + return initialize(context, bufferSize, indexType, mDynamicUsage); + } + + return angle::Result::Continue; +} + +angle::Result IndexBuffer11::discard(const gl::Context *context) +{ + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_HR(context11, mBuffer.valid(), "Internal index buffer is not initialized.", + E_OUTOFMEMORY); + + ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext(); + + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + dxContext->Unmap(mBuffer.get(), 0); + + return angle::Result::Continue; +} + +DXGI_FORMAT IndexBuffer11::getIndexFormat() const +{ + switch (mIndexType) + { + case gl::DrawElementsType::UnsignedByte: + return DXGI_FORMAT_R16_UINT; + case gl::DrawElementsType::UnsignedShort: + return DXGI_FORMAT_R16_UINT; + case gl::DrawElementsType::UnsignedInt: + return DXGI_FORMAT_R32_UINT; + default: + UNREACHABLE(); + return DXGI_FORMAT_UNKNOWN; + } +} + +const d3d11::Buffer &IndexBuffer11::getBuffer() const +{ + return mBuffer; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h new file mode 100644 index 0000000000..53c736cf7a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h @@ -0,0 +1,58 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// IndexBuffer11.h: Defines the D3D11 IndexBuffer implementation. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_INDEXBUFFER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_INDEXBUFFER11_H_ + +#include "libANGLE/renderer/d3d/IndexBuffer.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace rx +{ +class Renderer11; + +class IndexBuffer11 : public IndexBuffer +{ + public: + explicit IndexBuffer11(Renderer11 *const renderer); + ~IndexBuffer11() override; + + angle::Result initialize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType, + bool dynamic) override; + + angle::Result mapBuffer(const gl::Context *context, + unsigned int offset, + unsigned int size, + void **outMappedMemory) override; + angle::Result unmapBuffer(const gl::Context *context) override; + + gl::DrawElementsType getIndexType() const override; + unsigned int getBufferSize() const override; + angle::Result setSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) override; + + angle::Result discard(const gl::Context *context) override; + + DXGI_FORMAT getIndexFormat() const; + const d3d11::Buffer &getBuffer() const; + + private: + Renderer11 *const mRenderer; + + d3d11::Buffer mBuffer; + unsigned int mBufferSize; + gl::DrawElementsType mIndexType; + bool mDynamicUsage; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_INDEXBUFFER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp new file mode 100644 index 0000000000..b5e12499b2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp @@ -0,0 +1,313 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// InputLayoutCache.cpp: Defines InputLayoutCache, a class that builds and caches +// D3D11 input layouts. + +#include "libANGLE/renderer/d3d/d3d11/InputLayoutCache.h" + +#include "common/bitset_utils.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Program.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" + +namespace rx +{ + +namespace +{ + +GLenum GetGLSLAttributeType(const std::vector<sh::ShaderVariable> &shaderAttributes, size_t index) +{ + // Count matrices differently + for (const sh::ShaderVariable &attrib : shaderAttributes) + { + if (attrib.location == -1) + { + continue; + } + + GLenum transposedType = gl::TransposeMatrixType(attrib.type); + int rows = gl::VariableRowCount(transposedType); + int intIndex = static_cast<int>(index); + + if (intIndex >= attrib.location && intIndex < attrib.location + rows) + { + return transposedType; + } + } + + UNREACHABLE(); + return GL_NONE; +} + +struct PackedAttribute +{ + uint8_t attribType; + uint8_t semanticIndex; + uint8_t vertexFormatType; + uint8_t unusedPadding; + uint32_t divisor; +}; + +} // anonymous namespace + +PackedAttributeLayout::PackedAttributeLayout() : numAttributes(0), flags(0), attributeData({}) {} + +PackedAttributeLayout::PackedAttributeLayout(const PackedAttributeLayout &other) = default; + +void PackedAttributeLayout::addAttributeData(GLenum glType, + UINT semanticIndex, + angle::FormatID vertexFormatID, + unsigned int divisor) +{ + gl::AttributeType attribType = gl::GetAttributeType(glType); + + PackedAttribute packedAttrib; + packedAttrib.attribType = static_cast<uint8_t>(attribType); + packedAttrib.semanticIndex = static_cast<uint8_t>(semanticIndex); + packedAttrib.vertexFormatType = static_cast<uint8_t>(vertexFormatID); + packedAttrib.unusedPadding = 0u; + packedAttrib.divisor = static_cast<uint32_t>(divisor); + + ASSERT(static_cast<gl::AttributeType>(packedAttrib.attribType) == attribType); + ASSERT(static_cast<UINT>(packedAttrib.semanticIndex) == semanticIndex); + ASSERT(static_cast<angle::FormatID>(packedAttrib.vertexFormatType) == vertexFormatID); + ASSERT(static_cast<unsigned int>(packedAttrib.divisor) == divisor); + + static_assert(sizeof(uint64_t) == sizeof(PackedAttribute), + "PackedAttributes must be 64-bits exactly."); + + attributeData[numAttributes++] = gl::bitCast<uint64_t>(packedAttrib); +} + +bool PackedAttributeLayout::operator==(const PackedAttributeLayout &other) const +{ + return (numAttributes == other.numAttributes) && (flags == other.flags) && + (attributeData == other.attributeData); +} + +InputLayoutCache::InputLayoutCache() : mLayoutCache(kDefaultCacheSize * 2) {} + +InputLayoutCache::~InputLayoutCache() {} + +void InputLayoutCache::clear() +{ + mLayoutCache.Clear(); +} + +angle::Result InputLayoutCache::getInputLayout( + Context11 *context11, + const gl::State &state, + const std::vector<const TranslatedAttribute *> ¤tAttributes, + const AttribIndexArray &sortedSemanticIndices, + gl::PrimitiveMode mode, + GLsizei vertexCount, + GLsizei instances, + const d3d11::InputLayout **inputLayoutOut) +{ + gl::Program *program = state.getProgram(); + const auto &shaderAttributes = program->getAttributes(); + PackedAttributeLayout layout; + + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + bool programUsesInstancedPointSprites = + programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation(); + bool instancedPointSpritesActive = + programUsesInstancedPointSprites && (mode == gl::PrimitiveMode::Points); + + if (programUsesInstancedPointSprites) + { + layout.flags |= PackedAttributeLayout::FLAG_USES_INSTANCED_SPRITES; + } + + if (instancedPointSpritesActive) + { + layout.flags |= PackedAttributeLayout::FLAG_INSTANCED_SPRITES_ACTIVE; + } + + if (instances > 0) + { + layout.flags |= PackedAttributeLayout::FLAG_INSTANCED_RENDERING_ACTIVE; + } + + const auto &attribs = state.getVertexArray()->getVertexAttributes(); + const auto &bindings = state.getVertexArray()->getVertexBindings(); + const auto &locationToSemantic = programD3D->getAttribLocationToD3DSemantics(); + int divisorMultiplier = program->usesMultiview() ? program->getNumViews() : 1; + + for (size_t attribIndex : state.getProgramExecutable()->getActiveAttribLocationsMask()) + { + // Record the type of the associated vertex shader vector in our key + // This will prevent mismatched vertex shaders from using the same input layout + GLenum glslElementType = GetGLSLAttributeType(shaderAttributes, attribIndex); + + const auto &attrib = attribs[attribIndex]; + const auto &binding = bindings[attrib.bindingIndex]; + int d3dSemantic = locationToSemantic[attribIndex]; + + const auto ¤tValue = + state.getVertexAttribCurrentValue(static_cast<unsigned int>(attribIndex)); + angle::FormatID vertexFormatID = gl::GetVertexFormatID(attrib, currentValue.Type); + + layout.addAttributeData(glslElementType, d3dSemantic, vertexFormatID, + binding.getDivisor() * divisorMultiplier); + } + + if (layout.numAttributes > 0 || layout.flags != 0) + { + auto it = mLayoutCache.Get(layout); + if (it != mLayoutCache.end()) + { + *inputLayoutOut = &it->second; + } + else + { + angle::TrimCache(mLayoutCache.max_size() / 2, kGCLimit, "input layout", &mLayoutCache); + + d3d11::InputLayout newInputLayout; + ANGLE_TRY(createInputLayout(context11, sortedSemanticIndices, currentAttributes, mode, + vertexCount, instances, &newInputLayout)); + + auto insertIt = mLayoutCache.Put(layout, std::move(newInputLayout)); + *inputLayoutOut = &insertIt->second; + } + } + + return angle::Result::Continue; +} + +angle::Result InputLayoutCache::createInputLayout( + Context11 *context11, + const AttribIndexArray &sortedSemanticIndices, + const std::vector<const TranslatedAttribute *> ¤tAttributes, + gl::PrimitiveMode mode, + GLsizei vertexCount, + GLsizei instances, + d3d11::InputLayout *inputLayoutOut) +{ + Renderer11 *renderer = context11->getRenderer(); + ProgramD3D *programD3D = renderer->getStateManager()->getProgramD3D(); + D3D_FEATURE_LEVEL featureLevel = renderer->getRenderer11DeviceCaps().featureLevel; + + bool programUsesInstancedPointSprites = + programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation(); + + unsigned int inputElementCount = 0; + gl::AttribArray<D3D11_INPUT_ELEMENT_DESC> inputElements; + + for (size_t attribIndex = 0; attribIndex < currentAttributes.size(); ++attribIndex) + { + const auto &attrib = *currentAttributes[attribIndex]; + const int sortedIndex = sortedSemanticIndices[attribIndex]; + + D3D11_INPUT_CLASSIFICATION inputClass = + attrib.divisor > 0 ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA; + + angle::FormatID vertexFormatID = + gl::GetVertexFormatID(*attrib.attribute, attrib.currentValueType); + const auto &vertexFormatInfo = d3d11::GetVertexFormatInfo(vertexFormatID, featureLevel); + + auto *inputElement = &inputElements[inputElementCount]; + + inputElement->SemanticName = "TEXCOORD"; + inputElement->SemanticIndex = sortedIndex; + inputElement->Format = vertexFormatInfo.nativeFormat; + inputElement->InputSlot = static_cast<UINT>(attribIndex); + inputElement->AlignedByteOffset = 0; + inputElement->InputSlotClass = inputClass; + inputElement->InstanceDataStepRate = attrib.divisor; + + inputElementCount++; + } + + // Instanced PointSprite emulation requires additional entries in the + // inputlayout to support the vertices that make up the pointsprite quad. + // We do this even if mode != GL_POINTS, since the shader signature has these inputs, and the + // input layout must match the shader + if (programUsesInstancedPointSprites) + { + // On 9_3, we must ensure that slot 0 contains non-instanced data. + // If slot 0 currently contains instanced data then we swap it with a non-instanced element. + // Note that instancing is only available on 9_3 via ANGLE_instanced_arrays, since 9_3 + // doesn't support OpenGL ES 3.0. + // As per the spec for ANGLE_instanced_arrays, not all attributes can be instanced + // simultaneously, so a non-instanced element must exist. + + UINT numIndicesPerInstance = 0; + if (instances > 0) + { + // This requires that the index range is resolved. + // Note: Vertex indexes can be arbitrarily large. + numIndicesPerInstance = gl::clampCast<UINT>(vertexCount); + } + + for (size_t elementIndex = 0; elementIndex < inputElementCount; ++elementIndex) + { + // If rendering points and instanced pointsprite emulation is being used, the + // inputClass is required to be configured as per instance data + if (mode == gl::PrimitiveMode::Points) + { + inputElements[elementIndex].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA; + inputElements[elementIndex].InstanceDataStepRate = 1; + if (numIndicesPerInstance > 0 && currentAttributes[elementIndex]->divisor > 0) + { + inputElements[elementIndex].InstanceDataStepRate = numIndicesPerInstance; + } + } + inputElements[elementIndex].InputSlot++; + } + + inputElements[inputElementCount].SemanticName = "SPRITEPOSITION"; + inputElements[inputElementCount].SemanticIndex = 0; + inputElements[inputElementCount].Format = DXGI_FORMAT_R32G32B32_FLOAT; + inputElements[inputElementCount].InputSlot = 0; + inputElements[inputElementCount].AlignedByteOffset = 0; + inputElements[inputElementCount].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; + inputElements[inputElementCount].InstanceDataStepRate = 0; + inputElementCount++; + + inputElements[inputElementCount].SemanticName = "SPRITETEXCOORD"; + inputElements[inputElementCount].SemanticIndex = 0; + inputElements[inputElementCount].Format = DXGI_FORMAT_R32G32_FLOAT; + inputElements[inputElementCount].InputSlot = 0; + inputElements[inputElementCount].AlignedByteOffset = sizeof(float) * 3; + inputElements[inputElementCount].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; + inputElements[inputElementCount].InstanceDataStepRate = 0; + inputElementCount++; + } + + ShaderExecutableD3D *shader = nullptr; + ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(context11, &shader, nullptr)); + + ShaderExecutableD3D *shader11 = GetAs<ShaderExecutable11>(shader); + + InputElementArray inputElementArray(inputElements.data(), inputElementCount); + ShaderData vertexShaderData(shader11->getFunction(), shader11->getLength()); + + ANGLE_TRY(renderer->allocateResource(context11, inputElementArray, &vertexShaderData, + inputLayoutOut)); + return angle::Result::Continue; +} + +void InputLayoutCache::setCacheSize(size_t newCacheSize) +{ + // Forces a reset of the cache. + LayoutCache newCache(newCacheSize); + mLayoutCache.Swap(newCache); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h new file mode 100644 index 0000000000..35d1b60607 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h @@ -0,0 +1,123 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// InputLayoutCache.h: Defines InputLayoutCache, a class that builds and caches +// D3D11 input layouts. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_ + +#include <GLES2/gl2.h> + +#include <cstddef> + +#include <array> +#include <map> + +#include "common/angleutils.h" +#include "libANGLE/Constants.h" +#include "libANGLE/Error.h" +#include "libANGLE/SizedMRUCache.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace rx +{ +struct PackedAttributeLayout +{ + PackedAttributeLayout(); + PackedAttributeLayout(const PackedAttributeLayout &other); + + void addAttributeData(GLenum glType, + UINT semanticIndex, + angle::FormatID vertexFormatID, + unsigned int divisor); + + bool operator==(const PackedAttributeLayout &other) const; + + enum Flags + { + FLAG_USES_INSTANCED_SPRITES = 0x1, + FLAG_INSTANCED_SPRITES_ACTIVE = 0x2, + FLAG_INSTANCED_RENDERING_ACTIVE = 0x4, + }; + + uint32_t numAttributes; + uint32_t flags; + gl::AttribArray<uint64_t> attributeData; +}; +} // namespace rx + +namespace std +{ +template <> +struct hash<rx::PackedAttributeLayout> +{ + size_t operator()(const rx::PackedAttributeLayout &value) const + { + return angle::ComputeGenericHash(value); + } +}; +} // namespace std + +namespace gl +{ +class Program; +} // namespace gl + +namespace rx +{ +class Context11; +struct TranslatedAttribute; +struct TranslatedIndexData; +struct SourceIndexData; +class ProgramD3D; +class Renderer11; + +class InputLayoutCache : angle::NonCopyable +{ + public: + InputLayoutCache(); + ~InputLayoutCache(); + + void clear(); + + // Useful for testing + void setCacheSize(size_t newCacheSize); + + angle::Result getInputLayout(Context11 *context, + const gl::State &state, + const std::vector<const TranslatedAttribute *> ¤tAttributes, + const AttribIndexArray &sortedSemanticIndices, + gl::PrimitiveMode mode, + GLsizei vertexCount, + GLsizei instances, + const d3d11::InputLayout **inputLayoutOut); + + private: + angle::Result createInputLayout( + Context11 *context11, + const AttribIndexArray &sortedSemanticIndices, + const std::vector<const TranslatedAttribute *> ¤tAttributes, + gl::PrimitiveMode mode, + GLsizei vertexCount, + GLsizei instances, + d3d11::InputLayout *inputLayoutOut); + + // Starting cache size. + static constexpr size_t kDefaultCacheSize = 1024; + + // The cache tries to clean up this many states at once. + static constexpr size_t kGCLimit = 128; + + using LayoutCache = angle::base::HashingMRUCache<PackedAttributeLayout, d3d11::InputLayout>; + LayoutCache mLayoutCache; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.cpp new file mode 100644 index 0000000000..d0f6906f1e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.cpp @@ -0,0 +1,119 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// MappedSubresourceVerifier11.cpp: Implements the +// rx::MappedSubresourceVerifier11 class, a simple wrapper to D3D11 Texture2D +// mapped memory so that ASAN and MSAN can catch memory errors done with a +// pointer to the mapped texture memory. + +#include "libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.h" + +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" + +namespace rx +{ + +#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || defined(ANGLE_ENABLE_ASSERTS) + +namespace +{ + +# if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) +constexpr bool kUseWrap = true; +# else +constexpr bool kUseWrap = false; +# endif + +size_t getPitchCount(const D3D11_TEXTURE2D_DESC &desc) +{ + const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(desc.Format); + ASSERT(desc.Height % dxgiFormatInfo.blockHeight == 0); + return desc.Height / dxgiFormatInfo.blockHeight; +} + +} // namespace + +MappedSubresourceVerifier11::MappedSubresourceVerifier11() = default; + +MappedSubresourceVerifier11::~MappedSubresourceVerifier11() +{ + ASSERT(!mOrigData); + ASSERT(!mWrapData.size()); +} + +void MappedSubresourceVerifier11::setDesc(const D3D11_TEXTURE2D_DESC &desc) +{ + ASSERT(desc.CPUAccessFlags & (D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE)); + ASSERT(desc.Width); + ASSERT(desc.Height); + ASSERT(!mOrigData); + ASSERT(!mWrapData.size()); + ASSERT(!mPitchType); + ASSERT(!mPitchCount); + mPitchType = &D3D11_MAPPED_SUBRESOURCE::RowPitch; + mPitchCount = getPitchCount(desc); +} + +void MappedSubresourceVerifier11::setDesc(const D3D11_TEXTURE3D_DESC &desc) +{ + ASSERT(desc.CPUAccessFlags & (D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE)); + ASSERT(desc.Width); + ASSERT(desc.Height); + ASSERT(desc.Depth); + ASSERT(!mOrigData); + ASSERT(!mWrapData.size()); + ASSERT(!mPitchType); + ASSERT(!mPitchCount); + mPitchType = &D3D11_MAPPED_SUBRESOURCE::DepthPitch; + mPitchCount = desc.Depth; +} + +void MappedSubresourceVerifier11::reset() +{ + ASSERT(!mOrigData); + ASSERT(!mWrapData.size()); + mPitchType = nullptr; + mPitchCount = 0; +} + +bool MappedSubresourceVerifier11::wrap(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map) +{ + ASSERT(map && map->pData); + ASSERT(mapType == D3D11_MAP_READ || mapType == D3D11_MAP_WRITE || + mapType == D3D11_MAP_READ_WRITE); + ASSERT(mPitchCount); + + if (kUseWrap) + { + if (!mWrapData.resize(mPitchCount * map->*mPitchType)) + return false; + } + + mOrigData = reinterpret_cast<uint8_t *>(map->pData); + + if (kUseWrap) + { + std::copy(mOrigData, mOrigData + mWrapData.size(), mWrapData.data()); + map->pData = mWrapData.data(); + } + return true; +} + +void MappedSubresourceVerifier11::unwrap() +{ + ASSERT(mPitchCount); + ASSERT(mOrigData); + if (kUseWrap) + { + std::copy(mWrapData.data(), mWrapData.data() + mWrapData.size(), mOrigData); + mWrapData = angle::MemoryBuffer(); + } + mOrigData = nullptr; +} + +#endif + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.h new file mode 100644 index 0000000000..f0fc70eb85 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/MappedSubresourceVerifier11.h @@ -0,0 +1,63 @@ +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// MappedSubresourceVerifier11.h: Defines the rx::MappedSubresourceVerifier11 +// class, a simple wrapper to D3D11 Texture2D mapped memory so that ASAN +// MSAN can catch memory errors done with a pointer to the mapped texture +// memory. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_MAPPED_SUBRESOURCE_VERIFIER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_MAPPED_SUBRESOURCE_VERIFIER11_H_ + +#include "common/MemoryBuffer.h" +#include "common/angleutils.h" + +namespace rx +{ + +class MappedSubresourceVerifier11 final : angle::NonCopyable +{ + public: + MappedSubresourceVerifier11(); + ~MappedSubresourceVerifier11(); + + void setDesc(const D3D11_TEXTURE2D_DESC &desc); + void setDesc(const D3D11_TEXTURE3D_DESC &desc); + void reset(); + + bool wrap(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map); + void unwrap(); + + private: +#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || defined(ANGLE_ENABLE_ASSERTS) + UINT D3D11_MAPPED_SUBRESOURCE::*mPitchType = nullptr; + size_t mPitchCount = 0; + angle::MemoryBuffer mWrapData; + uint8_t *mOrigData = nullptr; +#endif +}; + +#if !(defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || defined(ANGLE_ENABLE_ASSERTS)) + +inline MappedSubresourceVerifier11::MappedSubresourceVerifier11() = default; +inline MappedSubresourceVerifier11::~MappedSubresourceVerifier11() = default; + +inline void MappedSubresourceVerifier11::setDesc(const D3D11_TEXTURE2D_DESC &desc) {} +inline void MappedSubresourceVerifier11::setDesc(const D3D11_TEXTURE3D_DESC &desc) {} +inline void MappedSubresourceVerifier11::reset() {} + +inline bool MappedSubresourceVerifier11::wrap(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map) +{ + return true; +} + +inline void MappedSubresourceVerifier11::unwrap() {} + +#endif + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_MAPPED_SUBRESOURCE_VERIFIER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/NativeWindow11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/NativeWindow11.h new file mode 100644 index 0000000000..e11b19cace --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/NativeWindow11.h @@ -0,0 +1,38 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindow11.h: Defines NativeWindow11, a class for managing and performing operations on an +// EGLNativeWindowType for the D3D11 renderer. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_NATIVEWINDOW11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_NATIVEWINDOW11_H_ + +#include "common/debug.h" +#include "common/platform.h" + +#include "libANGLE/Config.h" +#include "libANGLE/renderer/d3d/NativeWindowD3D.h" + +namespace rx +{ + +class NativeWindow11 : public NativeWindowD3D +{ + public: + NativeWindow11(EGLNativeWindowType window) : NativeWindowD3D(window) {} + + virtual HRESULT createSwapChain(ID3D11Device *device, + IDXGIFactory *factory, + DXGI_FORMAT format, + UINT width, + UINT height, + UINT samples, + IDXGISwapChain **swapChain) = 0; + virtual void commitChange() = 0; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_NATIVEWINDOW11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp new file mode 100644 index 0000000000..9649a91dd3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp @@ -0,0 +1,271 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// PixelTransfer11.cpp: +// Implementation for buffer-to-texture and texture-to-buffer copies. +// Used to implement pixel transfers from unpack and to pack buffers. +// + +#include "libANGLE/renderer/d3d/d3d11/PixelTransfer11.h" + +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/Texture.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "libANGLE/renderer/serial_utils.h" + +// Precompiled shaders +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4f.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4i.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4ui.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_vs.h" + +namespace rx +{ + +PixelTransfer11::PixelTransfer11(Renderer11 *renderer) + : mRenderer(renderer), + mResourcesLoaded(false), + mBufferToTextureVS(), + mBufferToTextureGS(), + mParamsConstantBuffer(), + mCopyRasterizerState(), + mCopyDepthStencilState() +{} + +PixelTransfer11::~PixelTransfer11() {} + +angle::Result PixelTransfer11::loadResources(const gl::Context *context) +{ + if (mResourcesLoaded) + { + return angle::Result::Continue; + } + + D3D11_RASTERIZER_DESC rasterDesc; + rasterDesc.FillMode = D3D11_FILL_SOLID; + rasterDesc.CullMode = D3D11_CULL_NONE; + rasterDesc.FrontCounterClockwise = FALSE; + rasterDesc.DepthBias = 0; + rasterDesc.SlopeScaledDepthBias = 0.0f; + rasterDesc.DepthBiasClamp = 0.0f; + rasterDesc.DepthClipEnable = TRUE; + rasterDesc.ScissorEnable = FALSE; + rasterDesc.MultisampleEnable = FALSE; + rasterDesc.AntialiasedLineEnable = FALSE; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mCopyRasterizerState)); + + D3D11_DEPTH_STENCIL_DESC depthStencilDesc; + depthStencilDesc.DepthEnable = true; + depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; + depthStencilDesc.DepthFunc = D3D11_COMPARISON_ALWAYS; + depthStencilDesc.StencilEnable = FALSE; + depthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; + depthStencilDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; + depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; + depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; + depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; + + ANGLE_TRY(mRenderer->allocateResource(context11, depthStencilDesc, &mCopyDepthStencilState)); + + D3D11_BUFFER_DESC constantBufferDesc = {}; + constantBufferDesc.ByteWidth = roundUpPow2<UINT>(sizeof(CopyShaderParams), 32u); + constantBufferDesc.Usage = D3D11_USAGE_DYNAMIC; + constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + constantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + constantBufferDesc.MiscFlags = 0; + constantBufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, constantBufferDesc, &mParamsConstantBuffer)); + mParamsConstantBuffer.setInternalName("PixelTransfer11ConstantBuffer"); + + // init shaders + ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_VS_BufferToTexture), + &mBufferToTextureVS)); + mBufferToTextureVS.setInternalName("BufferToTextureVS"); + + ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_GS_BufferToTexture), + &mBufferToTextureGS)); + mBufferToTextureGS.setInternalName("BufferToTextureGS"); + + ANGLE_TRY(buildShaderMap(context)); + + StructZero(&mParamsData); + + mResourcesLoaded = true; + + return angle::Result::Continue; +} + +void PixelTransfer11::setBufferToTextureCopyParams(const gl::Box &destArea, + const gl::Extents &destSize, + GLenum internalFormat, + const gl::PixelUnpackState &unpack, + unsigned int offset, + CopyShaderParams *parametersOut) +{ + StructZero(parametersOut); + + float texelCenterX = 0.5f / static_cast<float>(destSize.width); + float texelCenterY = 0.5f / static_cast<float>(destSize.height); + + unsigned int bytesPerPixel = gl::GetSizedInternalFormatInfo(internalFormat).pixelBytes; + unsigned int alignmentBytes = static_cast<unsigned int>(unpack.alignment); + unsigned int alignmentPixels = + (alignmentBytes <= bytesPerPixel ? 1 : alignmentBytes / bytesPerPixel); + + parametersOut->FirstPixelOffset = offset / bytesPerPixel; + parametersOut->PixelsPerRow = + static_cast<unsigned int>((unpack.rowLength > 0) ? unpack.rowLength : destArea.width); + parametersOut->RowStride = roundUp(parametersOut->PixelsPerRow, alignmentPixels); + parametersOut->RowsPerSlice = static_cast<unsigned int>(destArea.height); + parametersOut->PositionOffset[0] = + texelCenterX + (destArea.x / float(destSize.width)) * 2.0f - 1.0f; + parametersOut->PositionOffset[1] = + texelCenterY + ((destSize.height - destArea.y - 1) / float(destSize.height)) * 2.0f - 1.0f; + parametersOut->PositionScale[0] = 2.0f / static_cast<float>(destSize.width); + parametersOut->PositionScale[1] = -2.0f / static_cast<float>(destSize.height); + parametersOut->FirstSlice = destArea.z; +} + +angle::Result PixelTransfer11::copyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) +{ + ASSERT(unpackBuffer); + + ANGLE_TRY(loadResources(context)); + + gl::Extents destSize = destRenderTarget->getExtents(); + + ASSERT(destArea.x >= 0 && destArea.x + destArea.width <= destSize.width && destArea.y >= 0 && + destArea.y + destArea.height <= destSize.height && destArea.z >= 0 && + destArea.z + destArea.depth <= destSize.depth); + + ASSERT(mRenderer->supportsFastCopyBufferToTexture(destinationFormat)); + + const d3d11::PixelShader *pixelShader = findBufferToTexturePS(destinationFormat); + ASSERT(pixelShader); + + // The SRV must be in the proper read format, which may be different from the destination format + // EG: for half float data, we can load full precision floats with implicit conversion + GLenum unsizedFormat = gl::GetUnsizedFormat(destinationFormat); + const gl::InternalFormat &sourceglFormatInfo = + gl::GetInternalFormatInfo(unsizedFormat, sourcePixelsType); + + const d3d11::Format &sourceFormatInfo = d3d11::Format::Get( + sourceglFormatInfo.sizedInternalFormat, mRenderer->getRenderer11DeviceCaps()); + DXGI_FORMAT srvFormat = sourceFormatInfo.srvFormat; + ASSERT(srvFormat != DXGI_FORMAT_UNKNOWN); + Buffer11 *bufferStorage11 = GetAs<Buffer11>(unpackBuffer->getImplementation()); + const d3d11::ShaderResourceView *bufferSRV = nullptr; + ANGLE_TRY(bufferStorage11->getSRV(context, srvFormat, &bufferSRV)); + ASSERT(bufferSRV != nullptr); + + const d3d11::RenderTargetView &textureRTV = + GetAs<RenderTarget11>(destRenderTarget)->getRenderTargetView(); + ASSERT(textureRTV.valid()); + + CopyShaderParams shaderParams; + setBufferToTextureCopyParams(destArea, destSize, sourceglFormatInfo.sizedInternalFormat, unpack, + offset, &shaderParams); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // Are we doing a 2D or 3D copy? + const auto *geometryShader = ((destSize.depth > 1) ? &mBufferToTextureGS : nullptr); + StateManager11 *stateManager = mRenderer->getStateManager(); + + stateManager->setDrawShaders(&mBufferToTextureVS, geometryShader, pixelShader); + stateManager->setShaderResource(gl::ShaderType::Fragment, 0, bufferSRV); + stateManager->setInputLayout(nullptr); + stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST); + + stateManager->setSingleVertexBuffer(nullptr, 0, 0); + stateManager->setSimpleBlendState(nullptr); + stateManager->setDepthStencilState(&mCopyDepthStencilState, 0xFFFFFFFF); + stateManager->setRasterizerState(&mCopyRasterizerState); + + stateManager->setRenderTarget(textureRTV.get(), nullptr); + + if (!StructEquals(mParamsData, shaderParams)) + { + d3d11::SetBufferData(deviceContext, mParamsConstantBuffer.get(), shaderParams); + mParamsData = shaderParams; + } + + stateManager->setVertexConstantBuffer(0, &mParamsConstantBuffer); + + // Set the viewport + stateManager->setSimpleViewport(destSize); + + UINT numPixels = (shaderParams.PixelsPerRow * destArea.height * destArea.depth); + deviceContext->Draw(numPixels, 0); + + return angle::Result::Continue; +} + +angle::Result PixelTransfer11::buildShaderMap(const gl::Context *context) +{ + d3d11::PixelShader bufferToTextureFloat; + d3d11::PixelShader bufferToTextureInt; + d3d11::PixelShader bufferToTextureUint; + + Context11 *context11 = GetImplAs<Context11>(context); + + ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4F), + &bufferToTextureFloat)); + ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4I), + &bufferToTextureInt)); + ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4UI), + &bufferToTextureUint)); + + bufferToTextureFloat.setInternalName("BufferToTextureRGBA.ps"); + bufferToTextureInt.setInternalName("BufferToTextureRGBA-I.ps"); + bufferToTextureUint.setInternalName("BufferToTextureRGBA-UI.ps"); + + mBufferToTexturePSMap[GL_FLOAT] = std::move(bufferToTextureFloat); + mBufferToTexturePSMap[GL_INT] = std::move(bufferToTextureInt); + mBufferToTexturePSMap[GL_UNSIGNED_INT] = std::move(bufferToTextureUint); + + return angle::Result::Continue; +} + +const d3d11::PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const +{ + GLenum componentType = gl::GetSizedInternalFormatInfo(internalFormat).componentType; + if (componentType == GL_SIGNED_NORMALIZED || componentType == GL_UNSIGNED_NORMALIZED) + { + componentType = GL_FLOAT; + } + + auto shaderMapIt = mBufferToTexturePSMap.find(componentType); + return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : &shaderMapIt->second); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h new file mode 100644 index 0000000000..bdb11b90ff --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h @@ -0,0 +1,96 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// PixelTransfer11.h: +// Buffer-to-Texture and Texture-to-Buffer data transfers. +// Used to implement pixel unpack and pixel pack buffers in ES3. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_ + +#include <GLES2/gl2.h> + +#include <map> + +#include "common/platform.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace gl +{ +class Buffer; +class Context; +struct Box; +struct Extents; +struct PixelUnpackState; +} // namespace gl + +namespace rx +{ +class Renderer11; +class RenderTargetD3D; + +class PixelTransfer11 +{ + public: + explicit PixelTransfer11(Renderer11 *renderer); + ~PixelTransfer11(); + + // unpack: the source buffer is stored in the unpack state, and buffer strides + // offset: the start of the data within the unpack buffer + // destRenderTarget: individual slice/layer of a target texture + // destinationFormat/sourcePixelsType: determines shaders + shader parameters + // destArea: the sub-section of destRenderTarget to copy to + angle::Result copyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea); + + private: + struct CopyShaderParams + { + unsigned int FirstPixelOffset; + unsigned int PixelsPerRow; + unsigned int RowStride; + unsigned int RowsPerSlice; + float PositionOffset[2]; + float PositionScale[2]; + int TexLocationOffset[2]; + int TexLocationScale[2]; + unsigned int FirstSlice; + }; + + static void setBufferToTextureCopyParams(const gl::Box &destArea, + const gl::Extents &destSize, + GLenum internalFormat, + const gl::PixelUnpackState &unpack, + unsigned int offset, + CopyShaderParams *parametersOut); + + angle::Result loadResources(const gl::Context *context); + angle::Result buildShaderMap(const gl::Context *context); + const d3d11::PixelShader *findBufferToTexturePS(GLenum internalFormat) const; + + Renderer11 *mRenderer; + + bool mResourcesLoaded; + std::map<GLenum, d3d11::PixelShader> mBufferToTexturePSMap; + d3d11::VertexShader mBufferToTextureVS; + d3d11::GeometryShader mBufferToTextureGS; + d3d11::Buffer mParamsConstantBuffer; + CopyShaderParams mParamsData; + + d3d11::RasterizerState mCopyRasterizerState; + d3d11::DepthStencilState mCopyDepthStencilState; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.cpp new file mode 100644 index 0000000000..510065ccd6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.cpp @@ -0,0 +1,34 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Program11: D3D11 implementation of an OpenGL Program. + +#include "libANGLE/renderer/d3d/d3d11/Program11.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/StateManager11.h" + +namespace rx +{ +Program11::Program11(const gl::ProgramState &programState, Renderer11 *renderer) + : ProgramD3D(programState, renderer) +{} + +Program11::~Program11() = default; + +angle::Result Program11::syncState(const gl::Context *context, + const gl::Program::DirtyBits &dirtyBits) +{ + Renderer11 *renderer11 = GetImplAs<Context11>(context)->getRenderer(); + StateManager11 *stateManager = renderer11->getStateManager(); + + // This single flag should be replace by individual dirtyness. + stateManager->invalidateProgramUniformBuffers(); + + return angle::Result::Continue; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.h new file mode 100644 index 0000000000..2bd6bc3710 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Program11.h @@ -0,0 +1,28 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Program11: D3D11 implementation of an OpenGL Program. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_PROGRAM11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_PROGRAM11_H_ + +#include "libANGLE/renderer/d3d/ProgramD3D.h" + +namespace rx +{ +class Renderer11; + +class Program11 : public ProgramD3D +{ + public: + Program11(const gl::ProgramState &programState, Renderer11 *renderer11); + ~Program11() override; + + angle::Result syncState(const gl::Context *context, + const gl::Program::DirtyBits &dirtyBits) override; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_PROGRAM11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.cpp new file mode 100644 index 0000000000..2790809dde --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.cpp @@ -0,0 +1,21 @@ +// +// Copyright 2017 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ProgramPipelineNULL.cpp: +// Implements the class methods for ProgramPipeline11. +// + +#include "libANGLE/renderer/d3d/d3d11/ProgramPipeline11.h" + +namespace rx +{ + +ProgramPipeline11::ProgramPipeline11(const gl::ProgramPipelineState &state) + : ProgramPipelineImpl(state) +{} + +ProgramPipeline11::~ProgramPipeline11() {} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.h new file mode 100644 index 0000000000..cf838eec05 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ProgramPipeline11.h @@ -0,0 +1,27 @@ +// +// Copyright 2017 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ProgramPipeline11.h: +// Defines the class interface for ProgramPipeline11, implementing ProgramPipelineImpl. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_PROGRAMPIPELINE11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_PROGRAMPIPELINE11_H_ + +#include "libANGLE/renderer/ProgramPipelineImpl.h" + +namespace rx +{ + +class ProgramPipeline11 : public ProgramPipelineImpl +{ + public: + ProgramPipeline11(const gl::ProgramPipelineState &state); + ~ProgramPipeline11() override; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_PROGRAMPIPELINE11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.cpp new file mode 100644 index 0000000000..f2368e9f8f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.cpp @@ -0,0 +1,357 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Query11.cpp: Defines the rx::Query11 class which implements rx::QueryImpl. + +#include "libANGLE/renderer/d3d/d3d11/Query11.h" + +#include <GLES2/gl2ext.h> + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace +{ + +GLuint64 MergeQueryResults(gl::QueryType type, GLuint64 currentResult, GLuint64 newResult) +{ + switch (type) + { + case gl::QueryType::AnySamples: + case gl::QueryType::AnySamplesConservative: + return (currentResult == GL_TRUE || newResult == GL_TRUE) ? GL_TRUE : GL_FALSE; + + case gl::QueryType::TransformFeedbackPrimitivesWritten: + return currentResult + newResult; + + case gl::QueryType::TimeElapsed: + return currentResult + newResult; + + case gl::QueryType::Timestamp: + return newResult; + + case gl::QueryType::CommandsCompleted: + return newResult; + + default: + UNREACHABLE(); + return 0; + } +} + +} // anonymous namespace + +namespace rx +{ + +Query11::QueryState::QueryState() + : getDataAttemptCount(0), query(), beginTimestamp(), endTimestamp(), finished(false) +{} + +Query11::QueryState::~QueryState() {} + +Query11::Query11(Renderer11 *renderer, gl::QueryType type) + : QueryImpl(type), mResult(0), mResultSum(0), mRenderer(renderer) +{ + mActiveQuery = std::unique_ptr<QueryState>(new QueryState()); +} + +Query11::~Query11() +{ + mRenderer->getStateManager()->onDeleteQueryObject(this); +} + +angle::Result Query11::begin(const gl::Context *context) +{ + mResultSum = 0; + mRenderer->getStateManager()->onBeginQuery(this); + return resume(GetImplAs<Context11>(context)); +} + +angle::Result Query11::end(const gl::Context *context) +{ + return pause(GetImplAs<Context11>(context)); +} + +angle::Result Query11::queryCounter(const gl::Context *context) +{ + // This doesn't do anything for D3D11 as we don't support timestamps + ASSERT(getType() == gl::QueryType::Timestamp); + mResultSum = 0; + mPendingQueries.push_back(std::unique_ptr<QueryState>(new QueryState())); + return angle::Result::Continue; +} + +template <typename T> +angle::Result Query11::getResultBase(Context11 *context11, T *params) +{ + ASSERT(!mActiveQuery->query.valid()); + ANGLE_TRY(flush(context11, true)); + ASSERT(mPendingQueries.empty()); + *params = static_cast<T>(mResultSum); + + return angle::Result::Continue; +} + +angle::Result Query11::getResult(const gl::Context *context, GLint *params) +{ + return getResultBase(GetImplAs<Context11>(context), params); +} + +angle::Result Query11::getResult(const gl::Context *context, GLuint *params) +{ + return getResultBase(GetImplAs<Context11>(context), params); +} + +angle::Result Query11::getResult(const gl::Context *context, GLint64 *params) +{ + return getResultBase(GetImplAs<Context11>(context), params); +} + +angle::Result Query11::getResult(const gl::Context *context, GLuint64 *params) +{ + return getResultBase(GetImplAs<Context11>(context), params); +} + +angle::Result Query11::isResultAvailable(const gl::Context *context, bool *available) +{ + ANGLE_TRY(flush(GetImplAs<Context11>(context), false)); + + *available = mPendingQueries.empty(); + return angle::Result::Continue; +} + +angle::Result Query11::pause(Context11 *context11) +{ + if (mActiveQuery->query.valid()) + { + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + gl::QueryType type = getType(); + + // If we are doing time elapsed query the end timestamp + if (type == gl::QueryType::TimeElapsed) + { + context->End(mActiveQuery->endTimestamp.get()); + } + + context->End(mActiveQuery->query.get()); + + mPendingQueries.push_back(std::move(mActiveQuery)); + mActiveQuery = std::unique_ptr<QueryState>(new QueryState()); + } + + return flush(context11, false); +} + +angle::Result Query11::resume(Context11 *context11) +{ + if (!mActiveQuery->query.valid()) + { + ANGLE_TRY(flush(context11, false)); + + gl::QueryType type = getType(); + D3D11_QUERY d3dQueryType = gl_d3d11::ConvertQueryType(type); + + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = d3dQueryType; + queryDesc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, queryDesc, &mActiveQuery->query)); + + // If we are doing time elapsed we also need a query to actually query the timestamp + if (type == gl::QueryType::TimeElapsed) + { + D3D11_QUERY_DESC desc; + desc.Query = D3D11_QUERY_TIMESTAMP; + desc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, desc, &mActiveQuery->beginTimestamp)); + ANGLE_TRY(mRenderer->allocateResource(context11, desc, &mActiveQuery->endTimestamp)); + } + + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + + if (d3dQueryType != D3D11_QUERY_EVENT) + { + context->Begin(mActiveQuery->query.get()); + } + + // If we are doing time elapsed, query the begin timestamp + if (type == gl::QueryType::TimeElapsed) + { + context->End(mActiveQuery->beginTimestamp.get()); + } + } + + return angle::Result::Continue; +} + +angle::Result Query11::flush(Context11 *context11, bool force) +{ + while (!mPendingQueries.empty()) + { + QueryState *query = mPendingQueries.front().get(); + + do + { + ANGLE_TRY(testQuery(context11, query)); + if (!query->finished && !force) + { + return angle::Result::Continue; + } + } while (!query->finished); + + mResultSum = MergeQueryResults(getType(), mResultSum, mResult); + mPendingQueries.pop_front(); + } + + return angle::Result::Continue; +} + +angle::Result Query11::testQuery(Context11 *context11, QueryState *queryState) +{ + if (!queryState->finished) + { + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + switch (getType()) + { + case gl::QueryType::AnySamples: + case gl::QueryType::AnySamplesConservative: + { + ASSERT(queryState->query.valid()); + UINT64 numPixels = 0; + HRESULT result = + context->GetData(queryState->query.get(), &numPixels, sizeof(numPixels), 0); + ANGLE_TRY_HR(context11, result, "Failed to get the data of an internal query"); + + if (result == S_OK) + { + queryState->finished = true; + mResult = (numPixels > 0) ? GL_TRUE : GL_FALSE; + } + } + break; + + case gl::QueryType::TransformFeedbackPrimitivesWritten: + { + ASSERT(queryState->query.valid()); + D3D11_QUERY_DATA_SO_STATISTICS soStats = {}; + HRESULT result = + context->GetData(queryState->query.get(), &soStats, sizeof(soStats), 0); + ANGLE_TRY_HR(context11, result, "Failed to get the data of an internal query"); + + if (result == S_OK) + { + queryState->finished = true; + mResult = static_cast<GLuint64>(soStats.NumPrimitivesWritten); + } + } + break; + + case gl::QueryType::TimeElapsed: + { + ASSERT(queryState->query.valid()); + ASSERT(queryState->beginTimestamp.valid()); + ASSERT(queryState->endTimestamp.valid()); + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT timeStats = {}; + HRESULT result = + context->GetData(queryState->query.get(), &timeStats, sizeof(timeStats), 0); + ANGLE_TRY_HR(context11, result, "Failed to get the data of an internal query"); + + if (result == S_OK) + { + UINT64 beginTime = 0; + HRESULT beginRes = context->GetData(queryState->beginTimestamp.get(), + &beginTime, sizeof(UINT64), 0); + ANGLE_TRY_HR(context11, beginRes, + "Failed to get the data of an internal query"); + + UINT64 endTime = 0; + HRESULT endRes = context->GetData(queryState->endTimestamp.get(), &endTime, + sizeof(UINT64), 0); + ANGLE_TRY_HR(context11, endRes, "Failed to get the data of an internal query"); + + if (beginRes == S_OK && endRes == S_OK) + { + queryState->finished = true; + if (timeStats.Disjoint) + { + mRenderer->setGPUDisjoint(); + } + static_assert(sizeof(UINT64) == sizeof(unsigned long long), + "D3D UINT64 isn't 64 bits"); + + angle::CheckedNumeric<UINT64> checkedTime(endTime); + checkedTime -= beginTime; + checkedTime *= 1000000000ull; + checkedTime /= timeStats.Frequency; + if (checkedTime.IsValid()) + { + mResult = checkedTime.ValueOrDie(); + } + else + { + mResult = std::numeric_limits<GLuint64>::max() / timeStats.Frequency; + // If an overflow does somehow occur, there is no way the elapsed time + // is accurate, so we generate a disjoint event + mRenderer->setGPUDisjoint(); + } + } + } + } + break; + + case gl::QueryType::Timestamp: + { + // D3D11 doesn't support GL timestamp queries as D3D timestamps are not guaranteed + // to have any sort of continuity outside of a disjoint timestamp query block, which + // GL depends on + ASSERT(!queryState->query.valid()); + mResult = 0; + queryState->finished = true; + } + break; + + case gl::QueryType::CommandsCompleted: + { + ASSERT(queryState->query.valid()); + BOOL completed = 0; + HRESULT result = + context->GetData(queryState->query.get(), &completed, sizeof(completed), 0); + ANGLE_TRY_HR(context11, result, "Failed to get the data of an internal query"); + + if (result == S_OK) + { + queryState->finished = true; + ASSERT(completed == TRUE); + mResult = (completed == TRUE) ? GL_TRUE : GL_FALSE; + } + } + break; + + default: + UNREACHABLE(); + break; + } + + queryState->getDataAttemptCount++; + bool checkDeviceLost = + (queryState->getDataAttemptCount % kPollingD3DDeviceLostCheckFrequency) == 0; + if (!queryState->finished && checkDeviceLost && mRenderer->testDeviceLost()) + { + mRenderer->notifyDeviceLost(); + ANGLE_TRY_HR(context11, E_OUTOFMEMORY, + "Failed to test get query result, device is lost."); + } + } + + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.h new file mode 100644 index 0000000000..96ac59d742 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Query11.h @@ -0,0 +1,71 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Query11.h: Defines the rx::Query11 class which implements rx::QueryImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_QUERY11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_QUERY11_H_ + +#include <deque> + +#include "libANGLE/renderer/QueryImpl.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace rx +{ +class Context11; +class Renderer11; + +class Query11 : public QueryImpl +{ + public: + Query11(Renderer11 *renderer, gl::QueryType type); + ~Query11() override; + + angle::Result begin(const gl::Context *context) override; + angle::Result end(const gl::Context *context) override; + angle::Result queryCounter(const gl::Context *context) override; + angle::Result getResult(const gl::Context *context, GLint *params) override; + angle::Result getResult(const gl::Context *context, GLuint *params) override; + angle::Result getResult(const gl::Context *context, GLint64 *params) override; + angle::Result getResult(const gl::Context *context, GLuint64 *params) override; + angle::Result isResultAvailable(const gl::Context *context, bool *available) override; + + angle::Result pause(Context11 *context11); + angle::Result resume(Context11 *context11); + + private: + struct QueryState final : private angle::NonCopyable + { + QueryState(); + ~QueryState(); + + unsigned int getDataAttemptCount; + + d3d11::Query query; + d3d11::Query beginTimestamp; + d3d11::Query endTimestamp; + bool finished; + }; + + angle::Result flush(Context11 *context11, bool force); + angle::Result testQuery(Context11 *context11, QueryState *queryState); + + template <typename T> + angle::Result getResultBase(Context11 *context11, T *params); + + GLuint64 mResult; + GLuint64 mResultSum; + + Renderer11 *mRenderer; + + std::unique_ptr<QueryState> mActiveQuery; + std::deque<std::unique_ptr<QueryState>> mPendingQueries; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_QUERY11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp new file mode 100644 index 0000000000..964ac8c287 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp @@ -0,0 +1,323 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderStateCache.cpp: Defines rx::RenderStateCache, a cache of Direct3D render +// state objects. + +#include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h" + +#include <float.h> + +#include "common/Color.h" +#include "common/debug.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ +using namespace gl_d3d11; + +RenderStateCache::RenderStateCache() + : mBlendStateCache(kMaxStates), + mRasterizerStateCache(kMaxStates), + mDepthStencilStateCache(kMaxStates), + mSamplerStateCache(kMaxStates) +{} + +RenderStateCache::~RenderStateCache() {} + +void RenderStateCache::clear() +{ + mBlendStateCache.Clear(); + mRasterizerStateCache.Clear(); + mDepthStencilStateCache.Clear(); + mSamplerStateCache.Clear(); +} + +// static +d3d11::BlendStateKey RenderStateCache::GetBlendStateKey(const gl::Context *context, + Framebuffer11 *framebuffer11, + const gl::BlendStateExt &blendStateExt, + bool sampleAlphaToCoverage) +{ + d3d11::BlendStateKey key; + // All fields of the BlendStateExt inside the key should be initialized for the caching to + // work correctly. Due to mrt_perf_workaround, the actual indices of active draw buffers may be + // different, so both arrays should be tracked. + key.blendStateExt = gl::BlendStateExt(blendStateExt.getDrawBufferCount()); + const gl::AttachmentList &colorbuffers = framebuffer11->getColorAttachmentsForRender(context); + const gl::DrawBufferMask colorAttachmentsForRenderMask = + framebuffer11->getLastColorAttachmentsForRenderMask(); + + ASSERT(blendStateExt.getDrawBufferCount() <= colorAttachmentsForRenderMask.size()); + ASSERT(colorbuffers.size() == colorAttachmentsForRenderMask.count()); + + size_t keyBlendIndex = 0; + + // With blending disabled, factors and equations are ignored when building + // D3D11_RENDER_TARGET_BLEND_DESC, so we can reduce the amount of unique keys by + // enforcing default values. + for (size_t sourceIndex : colorAttachmentsForRenderMask) + { + ASSERT(keyBlendIndex < colorbuffers.size()); + const gl::FramebufferAttachment *attachment = colorbuffers[keyBlendIndex]; + + // Do not set blend state for null attachments that may be present when + // mrt_perf_workaround is disabled. + if (attachment == nullptr) + { + keyBlendIndex++; + continue; + } + + const uint8_t colorMask = blendStateExt.getColorMaskIndexed(sourceIndex); + + const gl::InternalFormat &internalFormat = *attachment->getFormat().info; + + key.blendStateExt.setColorMaskIndexed(keyBlendIndex, + gl_d3d11::GetColorMask(internalFormat) & colorMask); + key.rtvMax = static_cast<uint16_t>(keyBlendIndex) + 1; + + // Some D3D11 drivers produce unexpected results when blending is enabled for integer + // attachments. Per OpenGL ES spec, it must be ignored anyway. When blending is disabled, + // the state remains default to reduce the number of unique keys. + if (blendStateExt.getEnabledMask().test(sourceIndex) && !internalFormat.isInt()) + { + key.blendStateExt.setEnabledIndexed(keyBlendIndex, true); + key.blendStateExt.setEquationsIndexed(keyBlendIndex, sourceIndex, blendStateExt); + key.blendStateExt.setFactorsIndexed(keyBlendIndex, sourceIndex, blendStateExt); + } + keyBlendIndex++; + } + + key.sampleAlphaToCoverage = sampleAlphaToCoverage ? 1 : 0; + return key; +} + +angle::Result RenderStateCache::getBlendState(const gl::Context *context, + Renderer11 *renderer, + const d3d11::BlendStateKey &key, + const d3d11::BlendState **outBlendState) +{ + auto keyIter = mBlendStateCache.Get(key); + if (keyIter != mBlendStateCache.end()) + { + *outBlendState = &keyIter->second; + return angle::Result::Continue; + } + + TrimCache(kMaxStates, kGCLimit, "blend state", &mBlendStateCache); + + // Create a new blend state and insert it into the cache + D3D11_BLEND_DESC blendDesc = {}; // avoid undefined fields + const gl::BlendStateExt &blendStateExt = key.blendStateExt; + + blendDesc.AlphaToCoverageEnable = key.sampleAlphaToCoverage != 0 ? TRUE : FALSE; + blendDesc.IndependentBlendEnable = key.rtvMax > 1 ? TRUE : FALSE; + + // D3D11 API always accepts an array of blend states. Its validity depends on the hardware + // feature level. Given that we do not expose GL entrypoints that set per-buffer blend states on + // systems lower than FL10_1, this array will be always valid. + + for (size_t i = 0; i < blendStateExt.getDrawBufferCount(); i++) + { + D3D11_RENDER_TARGET_BLEND_DESC &rtDesc = blendDesc.RenderTarget[i]; + + if (blendStateExt.getEnabledMask().test(i)) + { + rtDesc.BlendEnable = true; + rtDesc.SrcBlend = + gl_d3d11::ConvertBlendFunc(blendStateExt.getSrcColorIndexed(i), false); + rtDesc.DestBlend = + gl_d3d11::ConvertBlendFunc(blendStateExt.getDstColorIndexed(i), false); + rtDesc.BlendOp = gl_d3d11::ConvertBlendOp(blendStateExt.getEquationColorIndexed(i)); + rtDesc.SrcBlendAlpha = + gl_d3d11::ConvertBlendFunc(blendStateExt.getSrcAlphaIndexed(i), true); + rtDesc.DestBlendAlpha = + gl_d3d11::ConvertBlendFunc(blendStateExt.getDstAlphaIndexed(i), true); + rtDesc.BlendOpAlpha = + gl_d3d11::ConvertBlendOp(blendStateExt.getEquationAlphaIndexed(i)); + } + + // blendStateExt.colorMask follows the same packing scheme as + // D3D11_RENDER_TARGET_BLEND_DESC.RenderTargetWriteMask + rtDesc.RenderTargetWriteMask = blendStateExt.getColorMaskIndexed(i); + } + + d3d11::BlendState d3dBlendState; + ANGLE_TRY(renderer->allocateResource(GetImplAs<Context11>(context), blendDesc, &d3dBlendState)); + const auto &iter = mBlendStateCache.Put(key, std::move(d3dBlendState)); + + *outBlendState = &iter->second; + + return angle::Result::Continue; +} + +angle::Result RenderStateCache::getRasterizerState(const gl::Context *context, + Renderer11 *renderer, + const gl::RasterizerState &rasterState, + bool scissorEnabled, + ID3D11RasterizerState **outRasterizerState) +{ + d3d11::RasterizerStateKey key; + key.rasterizerState = rasterState; + key.scissorEnabled = scissorEnabled ? 1 : 0; + + auto keyIter = mRasterizerStateCache.Get(key); + if (keyIter != mRasterizerStateCache.end()) + { + *outRasterizerState = keyIter->second.get(); + return angle::Result::Continue; + } + + TrimCache(kMaxStates, kGCLimit, "rasterizer state", &mRasterizerStateCache); + + D3D11_CULL_MODE cullMode = + gl_d3d11::ConvertCullMode(rasterState.cullFace, rasterState.cullMode); + + // Disable culling if drawing points + if (rasterState.pointDrawMode) + { + cullMode = D3D11_CULL_NONE; + } + + D3D11_RASTERIZER_DESC rasterDesc; + rasterDesc.FillMode = D3D11_FILL_SOLID; + rasterDesc.CullMode = cullMode; + rasterDesc.FrontCounterClockwise = (rasterState.frontFace == GL_CCW) ? FALSE : TRUE; + rasterDesc.DepthBiasClamp = 0.0f; // MSDN documentation of DepthBiasClamp implies a value of + // zero will preform no clamping, must be tested though. + rasterDesc.DepthClipEnable = TRUE; + rasterDesc.ScissorEnable = scissorEnabled ? TRUE : FALSE; + rasterDesc.MultisampleEnable = rasterState.multiSample; + rasterDesc.AntialiasedLineEnable = FALSE; + + if (rasterState.polygonOffsetFill) + { + rasterDesc.SlopeScaledDepthBias = rasterState.polygonOffsetFactor; + rasterDesc.DepthBias = (INT)rasterState.polygonOffsetUnits; + } + else + { + rasterDesc.SlopeScaledDepthBias = 0.0f; + rasterDesc.DepthBias = 0; + } + + d3d11::RasterizerState dx11RasterizerState; + ANGLE_TRY(renderer->allocateResource(GetImplAs<Context11>(context), rasterDesc, + &dx11RasterizerState)); + *outRasterizerState = dx11RasterizerState.get(); + mRasterizerStateCache.Put(key, std::move(dx11RasterizerState)); + + return angle::Result::Continue; +} + +angle::Result RenderStateCache::getDepthStencilState(const gl::Context *context, + Renderer11 *renderer, + const gl::DepthStencilState &glState, + const d3d11::DepthStencilState **outDSState) +{ + auto keyIter = mDepthStencilStateCache.Get(glState); + if (keyIter != mDepthStencilStateCache.end()) + { + *outDSState = &keyIter->second; + return angle::Result::Continue; + } + + TrimCache(kMaxStates, kGCLimit, "depth stencil state", &mDepthStencilStateCache); + + D3D11_DEPTH_STENCIL_DESC dsDesc = {}; + dsDesc.DepthEnable = glState.depthTest ? TRUE : FALSE; + dsDesc.DepthWriteMask = ConvertDepthMask(glState.depthMask); + dsDesc.DepthFunc = ConvertComparison(glState.depthFunc); + dsDesc.StencilEnable = glState.stencilTest ? TRUE : FALSE; + dsDesc.StencilReadMask = ConvertStencilMask(glState.stencilMask); + dsDesc.StencilWriteMask = ConvertStencilMask(glState.stencilWritemask); + dsDesc.FrontFace.StencilFailOp = ConvertStencilOp(glState.stencilFail); + dsDesc.FrontFace.StencilDepthFailOp = ConvertStencilOp(glState.stencilPassDepthFail); + dsDesc.FrontFace.StencilPassOp = ConvertStencilOp(glState.stencilPassDepthPass); + dsDesc.FrontFace.StencilFunc = ConvertComparison(glState.stencilFunc); + dsDesc.BackFace.StencilFailOp = ConvertStencilOp(glState.stencilBackFail); + dsDesc.BackFace.StencilDepthFailOp = ConvertStencilOp(glState.stencilBackPassDepthFail); + dsDesc.BackFace.StencilPassOp = ConvertStencilOp(glState.stencilBackPassDepthPass); + dsDesc.BackFace.StencilFunc = ConvertComparison(glState.stencilBackFunc); + + d3d11::DepthStencilState dx11DepthStencilState; + ANGLE_TRY( + renderer->allocateResource(GetImplAs<Context11>(context), dsDesc, &dx11DepthStencilState)); + const auto &iter = mDepthStencilStateCache.Put(glState, std::move(dx11DepthStencilState)); + + *outDSState = &iter->second; + + return angle::Result::Continue; +} + +angle::Result RenderStateCache::getSamplerState(const gl::Context *context, + Renderer11 *renderer, + const gl::SamplerState &samplerState, + ID3D11SamplerState **outSamplerState) +{ + auto keyIter = mSamplerStateCache.Get(samplerState); + if (keyIter != mSamplerStateCache.end()) + { + *outSamplerState = keyIter->second.get(); + return angle::Result::Continue; + } + + TrimCache(kMaxStates, kGCLimit, "sampler state", &mSamplerStateCache); + + const auto &featureLevel = renderer->getRenderer11DeviceCaps().featureLevel; + + D3D11_SAMPLER_DESC samplerDesc; + samplerDesc.Filter = + gl_d3d11::ConvertFilter(samplerState.getMinFilter(), samplerState.getMagFilter(), + samplerState.getMaxAnisotropy(), samplerState.getCompareMode()); + samplerDesc.AddressU = gl_d3d11::ConvertTextureWrap(samplerState.getWrapS()); + samplerDesc.AddressV = gl_d3d11::ConvertTextureWrap(samplerState.getWrapT()); + samplerDesc.AddressW = gl_d3d11::ConvertTextureWrap(samplerState.getWrapR()); + samplerDesc.MipLODBias = 0; + samplerDesc.MaxAnisotropy = + gl_d3d11::ConvertMaxAnisotropy(samplerState.getMaxAnisotropy(), featureLevel); + samplerDesc.ComparisonFunc = gl_d3d11::ConvertComparison(samplerState.getCompareFunc()); + angle::ColorF borderColor; + if (samplerState.getBorderColor().type == angle::ColorGeneric::Type::Float) + { + borderColor = samplerState.getBorderColor().colorF; + } + samplerDesc.BorderColor[0] = borderColor.red; + samplerDesc.BorderColor[1] = borderColor.green; + samplerDesc.BorderColor[2] = borderColor.blue; + samplerDesc.BorderColor[3] = borderColor.alpha; + samplerDesc.MinLOD = samplerState.getMinLod(); + samplerDesc.MaxLOD = samplerState.getMaxLod(); + + if (featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + // Check that maxLOD is nearly FLT_MAX (1000.0f is the default), since 9_3 doesn't support + // anything other than FLT_MAX. Note that Feature Level 9_* only supports GL ES 2.0, so the + // consumer of ANGLE can't modify the Max LOD themselves. + ASSERT(samplerState.getMaxLod() >= 999.9f); + + // Now just set MaxLOD to FLT_MAX. Other parts of the renderer (e.g. the non-zero max LOD + // workaround) should take account of this. + samplerDesc.MaxLOD = FLT_MAX; + } + + d3d11::SamplerState dx11SamplerState; + ANGLE_TRY( + renderer->allocateResource(GetImplAs<Context11>(context), samplerDesc, &dx11SamplerState)); + *outSamplerState = dx11SamplerState.get(); + mSamplerStateCache.Put(samplerState, std::move(dx11SamplerState)); + + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h new file mode 100644 index 0000000000..bd853fe86e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h @@ -0,0 +1,124 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderStateCache.h: Defines rx::RenderStateCache, a cache of Direct3D render +// state objects. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_ + +#include "common/angleutils.h" +#include "libANGLE/Error.h" +#include "libANGLE/SizedMRUCache.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include <unordered_map> + +namespace std +{ +template <> +struct hash<rx::d3d11::BlendStateKey> +{ + size_t operator()(const rx::d3d11::BlendStateKey &key) const + { + return angle::ComputeGenericHash(key); + } +}; + +template <> +struct hash<rx::d3d11::RasterizerStateKey> +{ + size_t operator()(const rx::d3d11::RasterizerStateKey &key) const + { + return angle::ComputeGenericHash(key); + } +}; + +template <> +struct hash<gl::DepthStencilState> +{ + size_t operator()(const gl::DepthStencilState &key) const + { + return angle::ComputeGenericHash(key); + } +}; + +template <> +struct hash<gl::SamplerState> +{ + size_t operator()(const gl::SamplerState &key) const { return angle::ComputeGenericHash(key); } +}; +} // namespace std + +namespace rx +{ +class Framebuffer11; +class Renderer11; + +class RenderStateCache : angle::NonCopyable +{ + public: + RenderStateCache(); + virtual ~RenderStateCache(); + + void clear(); + + static d3d11::BlendStateKey GetBlendStateKey(const gl::Context *context, + Framebuffer11 *framebuffer11, + const gl::BlendStateExt &blendStateExt, + bool sampleAlphaToCoverage); + angle::Result getBlendState(const gl::Context *context, + Renderer11 *renderer, + const d3d11::BlendStateKey &key, + const d3d11::BlendState **outBlendState); + angle::Result getRasterizerState(const gl::Context *context, + Renderer11 *renderer, + const gl::RasterizerState &rasterState, + bool scissorEnabled, + ID3D11RasterizerState **outRasterizerState); + angle::Result getDepthStencilState(const gl::Context *context, + Renderer11 *renderer, + const gl::DepthStencilState &dsState, + const d3d11::DepthStencilState **outDSState); + angle::Result getSamplerState(const gl::Context *context, + Renderer11 *renderer, + const gl::SamplerState &samplerState, + ID3D11SamplerState **outSamplerState); + + private: + // MSDN's documentation of ID3D11Device::CreateBlendState, ID3D11Device::CreateRasterizerState, + // ID3D11Device::CreateDepthStencilState and ID3D11Device::CreateSamplerState claims the maximum + // number of unique states of each type an application can create is 4096 + // TODO(ShahmeerEsmail): Revisit the cache sizes to make sure they are appropriate for most + // scenarios. + static constexpr unsigned int kMaxStates = 4096; + + // The cache tries to clean up this many states at once. + static constexpr unsigned int kGCLimit = 128; + + // Blend state cache + using BlendStateMap = angle::base::HashingMRUCache<d3d11::BlendStateKey, d3d11::BlendState>; + BlendStateMap mBlendStateCache; + + // Rasterizer state cache + using RasterizerStateMap = + angle::base::HashingMRUCache<d3d11::RasterizerStateKey, d3d11::RasterizerState>; + RasterizerStateMap mRasterizerStateCache; + + // Depth stencil state cache + using DepthStencilStateMap = + angle::base::HashingMRUCache<gl::DepthStencilState, d3d11::DepthStencilState>; + DepthStencilStateMap mDepthStencilStateCache; + + // Sample state cache + using SamplerStateMap = angle::base::HashingMRUCache<gl::SamplerState, d3d11::SamplerState>; + SamplerStateMap mSamplerStateCache; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp new file mode 100644 index 0000000000..2f550b5a77 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp @@ -0,0 +1,403 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTarget11.cpp: Implements a DX11-specific wrapper for ID3D11View pointers +// retained by Renderbuffers. + +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/SwapChain11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace rx +{ + +namespace +{ +bool GetTextureProperties(ID3D11Resource *resource, unsigned int *mipLevels, unsigned int *samples) +{ + ID3D11Texture1D *texture1D = d3d11::DynamicCastComObject<ID3D11Texture1D>(resource); + if (texture1D) + { + D3D11_TEXTURE1D_DESC texDesc; + texture1D->GetDesc(&texDesc); + SafeRelease(texture1D); + + *mipLevels = texDesc.MipLevels; + *samples = 0; + + return true; + } + + ID3D11Texture2D *texture2D = d3d11::DynamicCastComObject<ID3D11Texture2D>(resource); + if (texture2D) + { + D3D11_TEXTURE2D_DESC texDesc; + texture2D->GetDesc(&texDesc); + SafeRelease(texture2D); + + *mipLevels = texDesc.MipLevels; + *samples = texDesc.SampleDesc.Count > 1 ? texDesc.SampleDesc.Count : 0; + + return true; + } + + ID3D11Texture3D *texture3D = d3d11::DynamicCastComObject<ID3D11Texture3D>(resource); + if (texture3D) + { + D3D11_TEXTURE3D_DESC texDesc; + texture3D->GetDesc(&texDesc); + SafeRelease(texture3D); + + *mipLevels = texDesc.MipLevels; + *samples = 0; + + return true; + } + + return false; +} + +unsigned int GetRTVSubresourceIndex(ID3D11Resource *resource, ID3D11RenderTargetView *view) +{ + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + view->GetDesc(&rtvDesc); + + unsigned int mipSlice = 0; + unsigned int arraySlice = 0; + + switch (rtvDesc.ViewDimension) + { + case D3D11_RTV_DIMENSION_TEXTURE1D: + mipSlice = rtvDesc.Texture1D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE1DARRAY: + mipSlice = rtvDesc.Texture1DArray.MipSlice; + arraySlice = rtvDesc.Texture1DArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2D: + mipSlice = rtvDesc.Texture2D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DARRAY: + mipSlice = rtvDesc.Texture2DArray.MipSlice; + arraySlice = rtvDesc.Texture2DArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DMS: + mipSlice = 0; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY: + mipSlice = 0; + arraySlice = rtvDesc.Texture2DMSArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE3D: + mipSlice = rtvDesc.Texture3D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_UNKNOWN: + case D3D11_RTV_DIMENSION_BUFFER: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + break; + } + + unsigned int mipLevels, samples; + GetTextureProperties(resource, &mipLevels, &samples); + + return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels); +} + +unsigned int GetDSVSubresourceIndex(ID3D11Resource *resource, ID3D11DepthStencilView *view) +{ + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + view->GetDesc(&dsvDesc); + + unsigned int mipSlice = 0; + unsigned int arraySlice = 0; + + switch (dsvDesc.ViewDimension) + { + case D3D11_DSV_DIMENSION_TEXTURE1D: + mipSlice = dsvDesc.Texture1D.MipSlice; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE1DARRAY: + mipSlice = dsvDesc.Texture1DArray.MipSlice; + arraySlice = dsvDesc.Texture1DArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2D: + mipSlice = dsvDesc.Texture2D.MipSlice; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DARRAY: + mipSlice = dsvDesc.Texture2DArray.MipSlice; + arraySlice = dsvDesc.Texture2DArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DMS: + mipSlice = 0; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY: + mipSlice = 0; + arraySlice = dsvDesc.Texture2DMSArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_UNKNOWN: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + break; + } + + unsigned int mipLevels, samples; + GetTextureProperties(resource, &mipLevels, &samples); + + return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels); +} + +GLenum GetSurfaceRTFormat(bool depth, SwapChain11 *swapChain) +{ + return (depth ? swapChain->getDepthBufferInternalFormat() + : swapChain->getRenderTargetInternalFormat()); +} + +const d3d11::Format &GetSurfaceFormatSet(bool depth, SwapChain11 *swapChain, Renderer11 *renderer) +{ + return d3d11::Format::Get(GetSurfaceRTFormat(depth, swapChain), + renderer->getRenderer11DeviceCaps()); +} + +} // anonymous namespace + +RenderTarget11::RenderTarget11(const d3d11::Format &formatSet) : mFormatSet(formatSet) {} + +RenderTarget11::~RenderTarget11() {} + +TextureRenderTarget11::TextureRenderTarget11(d3d11::RenderTargetView &&rtv, + const TextureHelper11 &resource, + const d3d11::SharedSRV &srv, + const d3d11::SharedSRV &blitSRV, + GLenum internalFormat, + const d3d11::Format &formatSet, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples) + : RenderTarget11(formatSet), + mWidth(width), + mHeight(height), + mDepth(depth), + mInternalFormat(internalFormat), + mSamples(samples), + mSubresourceIndex(0), + mTexture(resource), + mRenderTarget(std::move(rtv)), + mDepthStencil(), + mShaderResource(srv.makeCopy()), + mBlitShaderResource(blitSRV.makeCopy()) +{ + if (mRenderTarget.valid() && mTexture.valid()) + { + mSubresourceIndex = GetRTVSubresourceIndex(mTexture.get(), mRenderTarget.get()); + } + ASSERT(mFormatSet.formatID != angle::FormatID::NONE || mWidth == 0 || mHeight == 0); +} + +TextureRenderTarget11::TextureRenderTarget11(d3d11::DepthStencilView &&dsv, + const TextureHelper11 &resource, + const d3d11::SharedSRV &srv, + GLenum internalFormat, + const d3d11::Format &formatSet, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples) + : RenderTarget11(formatSet), + mWidth(width), + mHeight(height), + mDepth(depth), + mInternalFormat(internalFormat), + mSamples(samples), + mSubresourceIndex(0), + mTexture(resource), + mRenderTarget(), + mDepthStencil(std::move(dsv)), + mShaderResource(srv.makeCopy()), + mBlitShaderResource() +{ + if (mDepthStencil.valid() && mTexture.valid()) + { + mSubresourceIndex = GetDSVSubresourceIndex(mTexture.get(), mDepthStencil.get()); + } + ASSERT(mFormatSet.formatID != angle::FormatID::NONE || mWidth == 0 || mHeight == 0); +} + +TextureRenderTarget11::~TextureRenderTarget11() {} + +const TextureHelper11 &TextureRenderTarget11::getTexture() const +{ + return mTexture; +} + +const d3d11::RenderTargetView &TextureRenderTarget11::getRenderTargetView() const +{ + return mRenderTarget; +} + +const d3d11::DepthStencilView &TextureRenderTarget11::getDepthStencilView() const +{ + return mDepthStencil; +} + +angle::Result TextureRenderTarget11::getShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) +{ + *outSRV = &mShaderResource; + return angle::Result::Continue; +} + +angle::Result TextureRenderTarget11::getBlitShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) +{ + *outSRV = &mBlitShaderResource; + return angle::Result::Continue; +} + +GLsizei TextureRenderTarget11::getWidth() const +{ + return mWidth; +} + +GLsizei TextureRenderTarget11::getHeight() const +{ + return mHeight; +} + +GLsizei TextureRenderTarget11::getDepth() const +{ + return mDepth; +} + +GLenum TextureRenderTarget11::getInternalFormat() const +{ + return mInternalFormat; +} + +GLsizei TextureRenderTarget11::getSamples() const +{ + return mSamples; +} + +unsigned int TextureRenderTarget11::getSubresourceIndex() const +{ + return mSubresourceIndex; +} + +SurfaceRenderTarget11::SurfaceRenderTarget11(SwapChain11 *swapChain, + Renderer11 *renderer, + bool depth) + : RenderTarget11(GetSurfaceFormatSet(depth, swapChain, renderer)), + mSwapChain(swapChain), + mDepth(depth) +{ + ASSERT(mSwapChain); +} + +SurfaceRenderTarget11::~SurfaceRenderTarget11() {} + +GLsizei SurfaceRenderTarget11::getWidth() const +{ + return mSwapChain->getWidth(); +} + +GLsizei SurfaceRenderTarget11::getHeight() const +{ + return mSwapChain->getHeight(); +} + +GLsizei SurfaceRenderTarget11::getDepth() const +{ + return 1; +} + +GLenum SurfaceRenderTarget11::getInternalFormat() const +{ + return GetSurfaceRTFormat(mDepth, mSwapChain); +} + +GLsizei SurfaceRenderTarget11::getSamples() const +{ + return mSwapChain->getSamples(); +} + +const TextureHelper11 &SurfaceRenderTarget11::getTexture() const +{ + return (mDepth ? mSwapChain->getDepthStencilTexture() : mSwapChain->getOffscreenTexture()); +} + +const d3d11::RenderTargetView &SurfaceRenderTarget11::getRenderTargetView() const +{ + ASSERT(!mDepth); + return mSwapChain->getRenderTarget(); +} + +const d3d11::DepthStencilView &SurfaceRenderTarget11::getDepthStencilView() const +{ + ASSERT(mDepth); + return mSwapChain->getDepthStencil(); +} + +angle::Result SurfaceRenderTarget11::getShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) +{ + if (mDepth) + { + *outSRV = &mSwapChain->getDepthStencilShaderResource(); + } + else + { + ANGLE_TRY(mSwapChain->getRenderTargetShaderResource(GetImplAs<Context11>(context), outSRV)); + } + return angle::Result::Continue; +} + +angle::Result SurfaceRenderTarget11::getBlitShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) +{ + // The SurfaceRenderTargetView format should always be such that the normal SRV works for blits. + return getShaderResourceView(context, outSRV); +} + +unsigned int SurfaceRenderTarget11::getSubresourceIndex() const +{ + return 0; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h new file mode 100644 index 0000000000..8467831e3b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h @@ -0,0 +1,133 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTarget11.h: Defines a DX11-specific wrapper for ID3D11View pointers +// retained by Renderbuffers. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERTARGET11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_RENDERTARGET11_H_ + +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace rx +{ +class SwapChain11; +class Renderer11; + +class RenderTarget11 : public RenderTargetD3D +{ + public: + RenderTarget11(const d3d11::Format &formatSet); + ~RenderTarget11() override; + + virtual const TextureHelper11 &getTexture() const = 0; + virtual const d3d11::RenderTargetView &getRenderTargetView() const = 0; + virtual const d3d11::DepthStencilView &getDepthStencilView() const = 0; + virtual angle::Result getShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) = 0; + virtual angle::Result getBlitShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) = 0; + + virtual unsigned int getSubresourceIndex() const = 0; + + const d3d11::Format &getFormatSet() const { return mFormatSet; } + + protected: + const d3d11::Format &mFormatSet; +}; + +class TextureRenderTarget11 : public RenderTarget11 +{ + public: + // TextureRenderTarget11 takes ownership of any D3D11 resources it is given and will AddRef them + TextureRenderTarget11(d3d11::RenderTargetView &&rtv, + const TextureHelper11 &resource, + const d3d11::SharedSRV &srv, + const d3d11::SharedSRV &blitSRV, + GLenum internalFormat, + const d3d11::Format &formatSet, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples); + TextureRenderTarget11(d3d11::DepthStencilView &&dsv, + const TextureHelper11 &resource, + const d3d11::SharedSRV &srv, + GLenum internalFormat, + const d3d11::Format &formatSet, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples); + ~TextureRenderTarget11() override; + + GLsizei getWidth() const override; + GLsizei getHeight() const override; + GLsizei getDepth() const override; + GLenum getInternalFormat() const override; + GLsizei getSamples() const override; + + const TextureHelper11 &getTexture() const override; + const d3d11::RenderTargetView &getRenderTargetView() const override; + const d3d11::DepthStencilView &getDepthStencilView() const override; + angle::Result getShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) override; + angle::Result getBlitShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) override; + + unsigned int getSubresourceIndex() const override; + + private: + GLsizei mWidth; + GLsizei mHeight; + GLsizei mDepth; + GLenum mInternalFormat; + GLsizei mSamples; + + unsigned int mSubresourceIndex; + TextureHelper11 mTexture; + d3d11::RenderTargetView mRenderTarget; + d3d11::DepthStencilView mDepthStencil; + d3d11::SharedSRV mShaderResource; + + // Shader resource view to use with internal blit shaders. Not set for depth/stencil render + // targets. + d3d11::SharedSRV mBlitShaderResource; +}; + +class SurfaceRenderTarget11 : public RenderTarget11 +{ + public: + SurfaceRenderTarget11(SwapChain11 *swapChain, Renderer11 *renderer, bool depth); + ~SurfaceRenderTarget11() override; + + GLsizei getWidth() const override; + GLsizei getHeight() const override; + GLsizei getDepth() const override; + GLenum getInternalFormat() const override; + GLsizei getSamples() const override; + + const TextureHelper11 &getTexture() const override; + const d3d11::RenderTargetView &getRenderTargetView() const override; + const d3d11::DepthStencilView &getDepthStencilView() const override; + angle::Result getShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) override; + angle::Result getBlitShaderResourceView(const gl::Context *context, + const d3d11::SharedSRV **outSRV) override; + + unsigned int getSubresourceIndex() const override; + + private: + SwapChain11 *mSwapChain; + bool mDepth; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERTARGET11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp new file mode 100644 index 0000000000..fdd264e92b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp @@ -0,0 +1,4454 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Renderer11.cpp: Implements a back-end specific class for the D3D11 renderer. + +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +#include <EGL/eglext.h> +#include <versionhelpers.h> +#include <sstream> + +#include "anglebase/no_destructor.h" +#include "common/tls.h" +#include "common/utilities.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Program.h" +#include "libANGLE/State.h" +#include "libANGLE/Surface.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/histogram_macros.h" +#include "libANGLE/renderer/d3d/CompilerD3D.h" +#include "libANGLE/renderer/d3d/DeviceD3D.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/SurfaceD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" +#include "libANGLE/renderer/d3d/d3d11/Blit11.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Clear11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/ExternalImageSiblingImpl11.h" +#include "libANGLE/renderer/d3d/d3d11/Fence11.h" +#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Image11.h" +#include "libANGLE/renderer/d3d/d3d11/IndexBuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/PixelTransfer11.h" +#include "libANGLE/renderer/d3d/d3d11/Program11.h" +#include "libANGLE/renderer/d3d/d3d11/Query11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h" +#include "libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h" +#include "libANGLE/renderer/d3d/d3d11/SwapChain11.h" +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" +#include "libANGLE/renderer/d3d/d3d11/Trim11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "libANGLE/renderer/d3d/driver_utils_d3d.h" +#include "libANGLE/renderer/driver_utils.h" +#include "libANGLE/renderer/dxgi_support_table.h" +#include "libANGLE/renderer/renderer_utils.h" +#include "libANGLE/trace.h" + +#ifdef ANGLE_ENABLE_WINDOWS_UWP +# include "libANGLE/renderer/d3d/d3d11/winrt/NativeWindow11WinRT.h" +#else +# include "libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.h" +#endif + +#ifdef ANGLE_ENABLE_D3D11_COMPOSITOR_NATIVE_WINDOW +# include "libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.h" +#endif + +// Enable ANGLE_SKIP_DXGI_1_2_CHECK if there is not a possibility of using cross-process +// HWNDs or the Windows 7 Platform Update (KB2670838) is expected to be installed. +#ifndef ANGLE_SKIP_DXGI_1_2_CHECK +# define ANGLE_SKIP_DXGI_1_2_CHECK 0 +#endif + +namespace rx +{ + +namespace +{ + +enum +{ + MAX_TEXTURE_IMAGE_UNITS_VTF_SM4 = 16 +}; + +enum ANGLEFeatureLevel +{ + ANGLE_FEATURE_LEVEL_INVALID, + ANGLE_FEATURE_LEVEL_9_3, + ANGLE_FEATURE_LEVEL_10_0, + ANGLE_FEATURE_LEVEL_10_1, + ANGLE_FEATURE_LEVEL_11_0, + ANGLE_FEATURE_LEVEL_11_1, + NUM_ANGLE_FEATURE_LEVELS +}; + +ANGLEFeatureLevel GetANGLEFeatureLevel(D3D_FEATURE_LEVEL d3dFeatureLevel) +{ + switch (d3dFeatureLevel) + { + case D3D_FEATURE_LEVEL_9_3: + return ANGLE_FEATURE_LEVEL_9_3; + case D3D_FEATURE_LEVEL_10_0: + return ANGLE_FEATURE_LEVEL_10_0; + case D3D_FEATURE_LEVEL_10_1: + return ANGLE_FEATURE_LEVEL_10_1; + case D3D_FEATURE_LEVEL_11_0: + return ANGLE_FEATURE_LEVEL_11_0; + case D3D_FEATURE_LEVEL_11_1: + return ANGLE_FEATURE_LEVEL_11_1; + default: + return ANGLE_FEATURE_LEVEL_INVALID; + } +} + +void SetLineLoopIndices(GLuint *dest, size_t count) +{ + for (size_t i = 0; i < count; i++) + { + dest[i] = static_cast<GLuint>(i); + } + dest[count] = 0; +} + +template <typename T> +void CopyLineLoopIndices(const void *indices, GLuint *dest, size_t count) +{ + const T *srcPtr = static_cast<const T *>(indices); + for (size_t i = 0; i < count; ++i) + { + dest[i] = static_cast<GLuint>(srcPtr[i]); + } + dest[count] = static_cast<GLuint>(srcPtr[0]); +} + +void SetTriangleFanIndices(GLuint *destPtr, size_t numTris) +{ + for (size_t i = 0; i < numTris; i++) + { + destPtr[i * 3 + 0] = 0; + destPtr[i * 3 + 1] = static_cast<GLuint>(i) + 1; + destPtr[i * 3 + 2] = static_cast<GLuint>(i) + 2; + } +} + +void GetLineLoopIndices(const void *indices, + gl::DrawElementsType indexType, + GLuint count, + bool usePrimitiveRestartFixedIndex, + std::vector<GLuint> *bufferOut) +{ + if (indexType != gl::DrawElementsType::InvalidEnum && usePrimitiveRestartFixedIndex) + { + size_t indexCount = GetLineLoopWithRestartIndexCount(indexType, count, + static_cast<const uint8_t *>(indices)); + bufferOut->resize(indexCount); + switch (indexType) + { + case gl::DrawElementsType::UnsignedByte: + CopyLineLoopIndicesWithRestart<GLubyte, GLuint>( + count, static_cast<const uint8_t *>(indices), + reinterpret_cast<uint8_t *>(bufferOut->data())); + break; + case gl::DrawElementsType::UnsignedShort: + CopyLineLoopIndicesWithRestart<GLushort, GLuint>( + count, static_cast<const uint8_t *>(indices), + reinterpret_cast<uint8_t *>(bufferOut->data())); + break; + case gl::DrawElementsType::UnsignedInt: + CopyLineLoopIndicesWithRestart<GLuint, GLuint>( + count, static_cast<const uint8_t *>(indices), + reinterpret_cast<uint8_t *>(bufferOut->data())); + break; + default: + UNREACHABLE(); + break; + } + return; + } + + // For non-primitive-restart draws, the index count is static. + bufferOut->resize(static_cast<size_t>(count) + 1); + + switch (indexType) + { + // Non-indexed draw + case gl::DrawElementsType::InvalidEnum: + SetLineLoopIndices(&(*bufferOut)[0], count); + break; + case gl::DrawElementsType::UnsignedByte: + CopyLineLoopIndices<GLubyte>(indices, &(*bufferOut)[0], count); + break; + case gl::DrawElementsType::UnsignedShort: + CopyLineLoopIndices<GLushort>(indices, &(*bufferOut)[0], count); + break; + case gl::DrawElementsType::UnsignedInt: + CopyLineLoopIndices<GLuint>(indices, &(*bufferOut)[0], count); + break; + default: + UNREACHABLE(); + break; + } +} + +template <typename T> +void CopyTriangleFanIndices(const void *indices, GLuint *destPtr, size_t numTris) +{ + const T *srcPtr = static_cast<const T *>(indices); + + for (size_t i = 0; i < numTris; i++) + { + destPtr[i * 3 + 0] = static_cast<GLuint>(srcPtr[0]); + destPtr[i * 3 + 1] = static_cast<GLuint>(srcPtr[i + 1]); + destPtr[i * 3 + 2] = static_cast<GLuint>(srcPtr[i + 2]); + } +} + +template <typename T> +void CopyTriangleFanIndicesWithRestart(const void *indices, + GLuint indexCount, + gl::DrawElementsType indexType, + std::vector<GLuint> *bufferOut) +{ + GLuint restartIndex = gl::GetPrimitiveRestartIndex(indexType); + GLuint d3dRestartIndex = gl::GetPrimitiveRestartIndex(gl::DrawElementsType::UnsignedInt); + const T *srcPtr = static_cast<const T *>(indices); + Optional<GLuint> vertexA; + Optional<GLuint> vertexB; + + bufferOut->clear(); + + for (size_t indexIdx = 0; indexIdx < indexCount; ++indexIdx) + { + GLuint value = static_cast<GLuint>(srcPtr[indexIdx]); + + if (value == restartIndex) + { + bufferOut->push_back(d3dRestartIndex); + vertexA.reset(); + vertexB.reset(); + } + else + { + if (!vertexA.valid()) + { + vertexA = value; + } + else if (!vertexB.valid()) + { + vertexB = value; + } + else + { + bufferOut->push_back(vertexA.value()); + bufferOut->push_back(vertexB.value()); + bufferOut->push_back(value); + vertexB = value; + } + } + } +} + +void GetTriFanIndices(const void *indices, + gl::DrawElementsType indexType, + GLuint count, + bool usePrimitiveRestartFixedIndex, + std::vector<GLuint> *bufferOut) +{ + if (indexType != gl::DrawElementsType::InvalidEnum && usePrimitiveRestartFixedIndex) + { + switch (indexType) + { + case gl::DrawElementsType::UnsignedByte: + CopyTriangleFanIndicesWithRestart<GLubyte>(indices, count, indexType, bufferOut); + break; + case gl::DrawElementsType::UnsignedShort: + CopyTriangleFanIndicesWithRestart<GLushort>(indices, count, indexType, bufferOut); + break; + case gl::DrawElementsType::UnsignedInt: + CopyTriangleFanIndicesWithRestart<GLuint>(indices, count, indexType, bufferOut); + break; + default: + UNREACHABLE(); + break; + } + return; + } + + // For non-primitive-restart draws, the index count is static. + GLuint numTris = count - 2; + bufferOut->resize(numTris * 3); + + switch (indexType) + { + // Non-indexed draw + case gl::DrawElementsType::InvalidEnum: + SetTriangleFanIndices(&(*bufferOut)[0], numTris); + break; + case gl::DrawElementsType::UnsignedByte: + CopyTriangleFanIndices<GLubyte>(indices, &(*bufferOut)[0], numTris); + break; + case gl::DrawElementsType::UnsignedShort: + CopyTriangleFanIndices<GLushort>(indices, &(*bufferOut)[0], numTris); + break; + case gl::DrawElementsType::UnsignedInt: + CopyTriangleFanIndices<GLuint>(indices, &(*bufferOut)[0], numTris); + break; + default: + UNREACHABLE(); + break; + } +} + +bool IsArrayRTV(ID3D11RenderTargetView *rtv) +{ + D3D11_RENDER_TARGET_VIEW_DESC desc; + rtv->GetDesc(&desc); + if (desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE1DARRAY && + desc.Texture1DArray.ArraySize > 1) + return true; + if (desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2DARRAY && + desc.Texture2DArray.ArraySize > 1) + return true; + if (desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY && + desc.Texture2DMSArray.ArraySize > 1) + return true; + return false; +} + +GLsizei GetAdjustedInstanceCount(const ProgramD3D *program, GLsizei instanceCount) +{ + if (!program->getState().usesMultiview()) + { + return instanceCount; + } + if (instanceCount == 0) + { + return program->getState().getNumViews(); + } + return program->getState().getNumViews() * instanceCount; +} + +const uint32_t ScratchMemoryBufferLifetime = 1000; + +void PopulateFormatDeviceCaps(ID3D11Device *device, + DXGI_FORMAT format, + UINT *outSupport, + UINT *outMaxSamples) +{ + if (FAILED(device->CheckFormatSupport(format, outSupport))) + { + *outSupport = 0; + } + + *outMaxSamples = 0; + for (UINT sampleCount = 2; sampleCount <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; sampleCount *= 2) + { + UINT qualityCount = 0; + if (FAILED(device->CheckMultisampleQualityLevels(format, sampleCount, &qualityCount)) || + qualityCount == 0) + { + break; + } + + *outMaxSamples = sampleCount; + } +} + +angle::Result GetTextureD3DResourceFromStorageOrImage(const gl::Context *context, + TextureD3D *texture, + const gl::ImageIndex &index, + const TextureHelper11 **outResource, + UINT *outSubresource) +{ + // If the storage exists, use it. Otherwise, copy directly from the images to avoid + // allocating a new storage. + if (texture->hasStorage()) + { + TextureStorage *storage = nullptr; + ANGLE_TRY(texture->getNativeTexture(context, &storage)); + + TextureStorage11 *storage11 = GetAs<TextureStorage11>(storage); + ANGLE_TRY(storage11->getResource(context, outResource)); + ANGLE_TRY(storage11->getSubresourceIndex(context, index, outSubresource)); + } + else + { + ImageD3D *image = texture->getImage(index); + Image11 *image11 = GetAs<Image11>(image); + ANGLE_TRY(image11->getStagingTexture(context, outResource, outSubresource)); + } + + return angle::Result::Continue; +} + +} // anonymous namespace + +Renderer11DeviceCaps::Renderer11DeviceCaps() = default; + +Renderer11::Renderer11(egl::Display *display) + : RendererD3D(display), + mCreateDebugDevice(false), + mStateCache(), + mStateManager(this), + mLastHistogramUpdateTime( + ANGLEPlatformCurrent()->monotonicallyIncreasingTime(ANGLEPlatformCurrent())), + mDebug(nullptr), + mScratchMemoryBuffer(ScratchMemoryBufferLifetime) +{ + mLineLoopIB = nullptr; + mTriangleFanIB = nullptr; + + mBlit = nullptr; + mPixelTransfer = nullptr; + + mClear = nullptr; + + mTrim = nullptr; + + mRenderer11DeviceCaps.supportsClearView = false; + mRenderer11DeviceCaps.supportsConstantBufferOffsets = false; + mRenderer11DeviceCaps.supportsVpRtIndexWriteFromVertexShader = false; + mRenderer11DeviceCaps.supportsDXGI1_2 = false; + mRenderer11DeviceCaps.allowES3OnFL10_0 = false; + mRenderer11DeviceCaps.supportsTypedUAVLoadAdditionalFormats = false; + mRenderer11DeviceCaps.supportsRasterizerOrderViews = false; + mRenderer11DeviceCaps.B5G6R5support = 0; + mRenderer11DeviceCaps.B4G4R4A4support = 0; + mRenderer11DeviceCaps.B5G5R5A1support = 0; + + mD3d11Module = nullptr; + mD3d12Module = nullptr; + mDxgiModule = nullptr; + mDCompModule = nullptr; + mCreatedWithDeviceEXT = false; + + mDevice = nullptr; + mDevice1 = nullptr; + mDeviceContext = nullptr; + mDeviceContext1 = nullptr; + mDeviceContext3 = nullptr; + mDxgiAdapter = nullptr; + mDxgiFactory = nullptr; + + ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription)); + + const auto &attributes = mDisplay->getAttributeMap(); + + if (mDisplay->getPlatform() == EGL_PLATFORM_ANGLE_ANGLE) + { + EGLint requestedMajorVersion = static_cast<EGLint>( + attributes.get(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, EGL_DONT_CARE)); + EGLint requestedMinorVersion = static_cast<EGLint>( + attributes.get(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE, EGL_DONT_CARE)); + + if (requestedMajorVersion == EGL_DONT_CARE || requestedMajorVersion >= 11) + { + if (requestedMinorVersion == EGL_DONT_CARE || requestedMinorVersion >= 1) + { + // This could potentially lead to failed context creation if done on a system + // without the platform update which installs DXGI 1.2. Currently, for Chrome users + // D3D11 contexts are only created if the platform update is available, so this + // should not cause any issues. + mAvailableFeatureLevels.push_back(D3D_FEATURE_LEVEL_11_1); + } + if (requestedMinorVersion == EGL_DONT_CARE || requestedMinorVersion >= 0) + { + mAvailableFeatureLevels.push_back(D3D_FEATURE_LEVEL_11_0); + } + } + + if (requestedMajorVersion == EGL_DONT_CARE || requestedMajorVersion >= 10) + { + if (requestedMinorVersion == EGL_DONT_CARE || requestedMinorVersion >= 1) + { + mAvailableFeatureLevels.push_back(D3D_FEATURE_LEVEL_10_1); + } + if (requestedMinorVersion == EGL_DONT_CARE || requestedMinorVersion >= 0) + { + mAvailableFeatureLevels.push_back(D3D_FEATURE_LEVEL_10_0); + } + } + + if (requestedMajorVersion == 9 && requestedMinorVersion == 3) + { + mAvailableFeatureLevels.push_back(D3D_FEATURE_LEVEL_9_3); + } + + EGLint requestedDeviceType = static_cast<EGLint>(attributes.get( + EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE)); + switch (requestedDeviceType) + { + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE: + mRequestedDriverType = D3D_DRIVER_TYPE_HARDWARE; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE: + mRequestedDriverType = D3D_DRIVER_TYPE_WARP; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE: + mRequestedDriverType = D3D_DRIVER_TYPE_REFERENCE; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE: + mRequestedDriverType = D3D_DRIVER_TYPE_NULL; + break; + + default: + UNREACHABLE(); + } + + mCreateDebugDevice = ShouldUseDebugLayers(attributes); + } + else if (mDisplay->getPlatform() == EGL_PLATFORM_DEVICE_EXT) + { + ASSERT(mDisplay->getDevice() != nullptr); + mCreatedWithDeviceEXT = true; + + // Also set EGL_PLATFORM_ANGLE_ANGLE variables, in case they're used elsewhere in ANGLE + // mAvailableFeatureLevels defaults to empty + mRequestedDriverType = D3D_DRIVER_TYPE_UNKNOWN; + } + + const EGLenum presentPath = static_cast<EGLenum>(attributes.get( + EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE, EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE)); + mPresentPathFastEnabled = (presentPath == EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE); +} + +Renderer11::~Renderer11() +{ + release(); +} + +#ifndef __d3d11_1_h__ +# define D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET ((D3D11_MESSAGE_ID)3146081) +#endif + +egl::Error Renderer11::initialize() +{ + HRESULT result = S_OK; + + ANGLE_TRY(initializeD3DDevice()); + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) +# if !ANGLE_SKIP_DXGI_1_2_CHECK + { + ANGLE_TRACE_EVENT0("gpu.angle", "Renderer11::initialize (DXGICheck)"); + // In order to create a swap chain for an HWND owned by another process, DXGI 1.2 is + // required. + // The easiest way to check is to query for a IDXGIDevice2. + bool requireDXGI1_2 = false; + HWND hwnd = WindowFromDC(mDisplay->getNativeDisplayId()); + if (hwnd) + { + DWORD currentProcessId = GetCurrentProcessId(); + DWORD wndProcessId; + GetWindowThreadProcessId(hwnd, &wndProcessId); + requireDXGI1_2 = (currentProcessId != wndProcessId); + } + else + { + requireDXGI1_2 = true; + } + + if (requireDXGI1_2) + { + IDXGIDevice2 *dxgiDevice2 = nullptr; + result = mDevice->QueryInterface(__uuidof(IDXGIDevice2), (void **)&dxgiDevice2); + if (FAILED(result)) + { + return egl::EglNotInitialized(D3D11_INIT_INCOMPATIBLE_DXGI) + << "DXGI 1.2 required to present to HWNDs owned by another process."; + } + SafeRelease(dxgiDevice2); + } + } +# endif +#endif + + { + ANGLE_TRACE_EVENT0("gpu.angle", "Renderer11::initialize (ComQueries)"); + // Cast the DeviceContext to a DeviceContext1 and DeviceContext3. + // This could fail on Windows 7 without the Platform Update. + // Don't error in this case- just don't use mDeviceContext1 or mDeviceContext3. + mDeviceContext1 = d3d11::DynamicCastComObject<ID3D11DeviceContext1>(mDeviceContext); + mDeviceContext3 = d3d11::DynamicCastComObject<ID3D11DeviceContext3>(mDeviceContext); + + IDXGIDevice *dxgiDevice = nullptr; + result = mDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&dxgiDevice); + + if (FAILED(result)) + { + return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR) << "Could not query DXGI device."; + } + + result = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&mDxgiAdapter); + + if (FAILED(result)) + { + return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR) + << "Could not retrieve DXGI adapter"; + } + + SafeRelease(dxgiDevice); + + IDXGIAdapter2 *dxgiAdapter2 = d3d11::DynamicCastComObject<IDXGIAdapter2>(mDxgiAdapter); + + // On D3D_FEATURE_LEVEL_9_*, IDXGIAdapter::GetDesc returns "Software Adapter" for the + // description string. + // If DXGI1.2 is available then IDXGIAdapter2::GetDesc2 can be used to get the actual + // hardware values. + if (mRenderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3 && dxgiAdapter2 != nullptr) + { + DXGI_ADAPTER_DESC2 adapterDesc2 = {}; + result = dxgiAdapter2->GetDesc2(&adapterDesc2); + if (SUCCEEDED(result)) + { + // Copy the contents of the DXGI_ADAPTER_DESC2 into mAdapterDescription (a + // DXGI_ADAPTER_DESC). + memcpy(mAdapterDescription.Description, adapterDesc2.Description, + sizeof(mAdapterDescription.Description)); + mAdapterDescription.VendorId = adapterDesc2.VendorId; + mAdapterDescription.DeviceId = adapterDesc2.DeviceId; + mAdapterDescription.SubSysId = adapterDesc2.SubSysId; + mAdapterDescription.Revision = adapterDesc2.Revision; + mAdapterDescription.DedicatedVideoMemory = adapterDesc2.DedicatedVideoMemory; + mAdapterDescription.DedicatedSystemMemory = adapterDesc2.DedicatedSystemMemory; + mAdapterDescription.SharedSystemMemory = adapterDesc2.SharedSystemMemory; + mAdapterDescription.AdapterLuid = adapterDesc2.AdapterLuid; + } + } + else + { + result = mDxgiAdapter->GetDesc(&mAdapterDescription); + } + + SafeRelease(dxgiAdapter2); + + if (FAILED(result)) + { + return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR) + << "Could not read DXGI adaptor description."; + } + + memset(mDescription, 0, sizeof(mDescription)); + wcstombs(mDescription, mAdapterDescription.Description, sizeof(mDescription) - 1); + + result = mDxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void **)&mDxgiFactory); + + if (!mDxgiFactory || FAILED(result)) + { + return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR) + << "Could not create DXGI factory."; + } + } + + // Disable some spurious D3D11 debug warnings to prevent them from flooding the output log + if (mCreateDebugDevice) + { + ANGLE_TRACE_EVENT0("gpu.angle", "Renderer11::initialize (HideWarnings)"); + ID3D11InfoQueue *infoQueue; + result = mDevice->QueryInterface(__uuidof(ID3D11InfoQueue), (void **)&infoQueue); + + if (SUCCEEDED(result)) + { + D3D11_MESSAGE_ID hideMessages[] = { + D3D11_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET, + + // Robust access behaviour makes out of bounds messages safe + D3D11_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL, + }; + + D3D11_INFO_QUEUE_FILTER filter = {}; + filter.DenyList.NumIDs = static_cast<unsigned int>(ArraySize(hideMessages)); + filter.DenyList.pIDList = hideMessages; + + infoQueue->AddStorageFilterEntries(&filter); + SafeRelease(infoQueue); + } + } + +#if !defined(NDEBUG) + mDebug = d3d11::DynamicCastComObject<ID3D11Debug>(mDevice); +#endif + + ANGLE_TRY(initializeDevice()); + + return egl::NoError(); +} + +HRESULT Renderer11::callD3D11CreateDevice(PFN_D3D11_CREATE_DEVICE createDevice, bool debug) +{ + angle::ComPtr<IDXGIAdapter> adapter; + + const egl::AttributeMap &attributes = mDisplay->getAttributeMap(); + // Check EGL_ANGLE_platform_angle_d3d_luid + long high = static_cast<long>(attributes.get(EGL_PLATFORM_ANGLE_D3D_LUID_HIGH_ANGLE, 0)); + unsigned long low = + static_cast<unsigned long>(attributes.get(EGL_PLATFORM_ANGLE_D3D_LUID_LOW_ANGLE, 0)); + // Check EGL_ANGLE_platform_angle_device_id + if (high == 0 && low == 0) + { + high = static_cast<long>(attributes.get(EGL_PLATFORM_ANGLE_DEVICE_ID_HIGH_ANGLE, 0)); + low = static_cast<unsigned long>(attributes.get(EGL_PLATFORM_ANGLE_DEVICE_ID_LOW_ANGLE, 0)); + } + if (high != 0 || low != 0) + { + angle::ComPtr<IDXGIFactory1> factory; + if (SUCCEEDED(CreateDXGIFactory1(IID_PPV_ARGS(&factory)))) + { + angle::ComPtr<IDXGIAdapter> temp; + for (UINT i = 0; SUCCEEDED(factory->EnumAdapters(i, &temp)); i++) + { + DXGI_ADAPTER_DESC desc; + if (SUCCEEDED(temp->GetDesc(&desc))) + { + // EGL_ANGLE_platform_angle_d3d_luid + if (desc.AdapterLuid.HighPart == high && desc.AdapterLuid.LowPart == low) + { + adapter = temp; + break; + } + + // EGL_ANGLE_platform_angle_device_id + // NOTE: If there are multiple GPUs with the same PCI + // vendor and device IDs, this will arbitrarily choose one + // of them. To select a specific GPU, use the LUID instead. + if ((high == 0 || desc.VendorId == static_cast<UINT>(high)) && + (low == 0 || desc.DeviceId == static_cast<UINT>(low))) + { + adapter = temp; + break; + } + } + } + } + } + + // If adapter is not nullptr, the driver type must be D3D_DRIVER_TYPE_UNKNOWN or + // D3D11CreateDevice will return E_INVALIDARG. + return createDevice( + adapter.Get(), adapter ? D3D_DRIVER_TYPE_UNKNOWN : mRequestedDriverType, nullptr, + debug ? D3D11_CREATE_DEVICE_DEBUG : 0, mAvailableFeatureLevels.data(), + static_cast<unsigned int>(mAvailableFeatureLevels.size()), D3D11_SDK_VERSION, &mDevice, + &(mRenderer11DeviceCaps.featureLevel), &mDeviceContext); +} + +HRESULT Renderer11::callD3D11On12CreateDevice(PFN_D3D12_CREATE_DEVICE createDevice12, + PFN_D3D11ON12_CREATE_DEVICE createDevice11on12, + bool debug) +{ + angle::ComPtr<IDXGIFactory4> factory; + HRESULT result = CreateDXGIFactory1(IID_PPV_ARGS(&factory)); + if (FAILED(result)) + { + return result; + } + + if (mRequestedDriverType == D3D_DRIVER_TYPE_WARP) + { + angle::ComPtr<IDXGIAdapter> warpAdapter; + result = factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter)); + if (SUCCEEDED(result)) + { + result = createDevice12(warpAdapter.Get(), mAvailableFeatureLevels[0], + IID_PPV_ARGS(&mDevice12)); + } + } + else + { + // Passing nullptr into pAdapter chooses the default adapter which will be the hardware + // adapter if it exists. + result = createDevice12(nullptr, mAvailableFeatureLevels[0], IID_PPV_ARGS(&mDevice12)); + } + + if (SUCCEEDED(result)) + { + D3D12_COMMAND_QUEUE_DESC queueDesc = {}; + queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; + queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; + result = mDevice12->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue)); + } + + if (SUCCEEDED(result)) + { + result = createDevice11on12( + mDevice12.Get(), debug ? D3D11_CREATE_DEVICE_DEBUG : 0, mAvailableFeatureLevels.data(), + static_cast<unsigned int>(mAvailableFeatureLevels.size()), + reinterpret_cast<IUnknown **>(mCommandQueue.GetAddressOf()), 1 /* NumQueues */, + 0 /* NodeMask */, &mDevice, &mDeviceContext, &(mRenderer11DeviceCaps.featureLevel)); + } + + return result; +} + +egl::Error Renderer11::initializeD3DDevice() +{ + HRESULT result = S_OK; + bool createD3D11on12Device = false; + + if (!mCreatedWithDeviceEXT) + { +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = nullptr; + PFN_D3D12_CREATE_DEVICE D3D12CreateDevice = nullptr; + PFN_D3D11ON12_CREATE_DEVICE D3D11On12CreateDevice = nullptr; + { + ANGLE_TRACE_EVENT0("gpu.angle", "Renderer11::initialize (Load DLLs)"); + mDxgiModule = LoadLibrary(TEXT("dxgi.dll")); + mD3d11Module = LoadLibrary(TEXT("d3d11.dll")); + mDCompModule = LoadLibrary(TEXT("dcomp.dll")); + + // create the D3D11 device + ASSERT(mDevice == nullptr); + + const egl::AttributeMap &attributes = mDisplay->getAttributeMap(); + createD3D11on12Device = + attributes.get(EGL_PLATFORM_ANGLE_D3D11ON12_ANGLE, EGL_FALSE) == EGL_TRUE; + + if (createD3D11on12Device) + { + mD3d12Module = LoadLibrary(TEXT("d3d12.dll")); + if (mD3d12Module == nullptr) + { + return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP) + << "Could not load D3D12 library."; + } + + D3D12CreateDevice = reinterpret_cast<PFN_D3D12_CREATE_DEVICE>( + GetProcAddress(mD3d12Module, "D3D12CreateDevice")); + if (D3D12CreateDevice == nullptr) + { + return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP) + << "Could not retrieve D3D12CreateDevice address."; + } + + D3D11On12CreateDevice = reinterpret_cast<PFN_D3D11ON12_CREATE_DEVICE>( + GetProcAddress(mD3d11Module, "D3D11On12CreateDevice")); + if (D3D11On12CreateDevice == nullptr) + { + return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP) + << "Could not retrieve D3D11On12CreateDevice address."; + } + } + else + { + if (mD3d11Module == nullptr || mDxgiModule == nullptr) + { + return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP) + << "Could not load D3D11 or DXGI library."; + } + + D3D11CreateDevice = reinterpret_cast<PFN_D3D11_CREATE_DEVICE>( + GetProcAddress(mD3d11Module, "D3D11CreateDevice")); + + if (D3D11CreateDevice == nullptr) + { + return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP) + << "Could not retrieve D3D11CreateDevice address."; + } + } + } +#endif + + if (mCreateDebugDevice) + { + ANGLE_TRACE_EVENT0("gpu.angle", "D3D11CreateDevice (Debug)"); + if (createD3D11on12Device) + { + result = callD3D11On12CreateDevice(D3D12CreateDevice, D3D11On12CreateDevice, true); + } + else + { + result = callD3D11CreateDevice(D3D11CreateDevice, true); + } + + if (result == E_INVALIDARG && mAvailableFeatureLevels.size() > 1u && + mAvailableFeatureLevels[0] == D3D_FEATURE_LEVEL_11_1) + { + // On older Windows platforms, D3D11.1 is not supported which returns E_INVALIDARG. + // Try again without passing D3D_FEATURE_LEVEL_11_1 in case we have other feature + // levels to fall back on. + mAvailableFeatureLevels.erase(mAvailableFeatureLevels.begin()); + if (createD3D11on12Device) + { + result = + callD3D11On12CreateDevice(D3D12CreateDevice, D3D11On12CreateDevice, true); + } + else + { + result = callD3D11CreateDevice(D3D11CreateDevice, true); + } + } + + if (!mDevice || FAILED(result)) + { + WARN() << "Failed creating Debug D3D11 device - falling back to release runtime."; + } + } + + if (!mDevice || FAILED(result)) + { + ANGLE_TRACE_EVENT0("gpu.angle", "D3D11CreateDevice"); + if (createD3D11on12Device) + { + result = callD3D11On12CreateDevice(D3D12CreateDevice, D3D11On12CreateDevice, false); + } + else + { + result = callD3D11CreateDevice(D3D11CreateDevice, false); + } + + if (result == E_INVALIDARG && mAvailableFeatureLevels.size() > 1u && + mAvailableFeatureLevels[0] == D3D_FEATURE_LEVEL_11_1) + { + // On older Windows platforms, D3D11.1 is not supported which returns E_INVALIDARG. + // Try again without passing D3D_FEATURE_LEVEL_11_1 in case we have other feature + // levels to fall back on. + mAvailableFeatureLevels.erase(mAvailableFeatureLevels.begin()); + if (createD3D11on12Device) + { + result = + callD3D11On12CreateDevice(D3D12CreateDevice, D3D11On12CreateDevice, false); + } + else + { + result = callD3D11CreateDevice(D3D11CreateDevice, false); + } + } + + // Cleanup done by destructor + if (!mDevice || FAILED(result)) + { + ANGLE_HISTOGRAM_SPARSE_SLOWLY("GPU.ANGLE.D3D11CreateDeviceError", + static_cast<int>(result)); + return egl::EglNotInitialized(D3D11_INIT_CREATEDEVICE_ERROR) + << "Could not create D3D11 device."; + } + } + } + else + { + DeviceD3D *deviceD3D = GetImplAs<DeviceD3D>(mDisplay->getDevice()); + ASSERT(deviceD3D != nullptr); + + // We should use the inputted D3D11 device instead + void *device = nullptr; + ANGLE_TRY(deviceD3D->getAttribute(mDisplay, EGL_D3D11_DEVICE_ANGLE, &device)); + + ID3D11Device *d3dDevice = static_cast<ID3D11Device *>(device); + if (FAILED(d3dDevice->GetDeviceRemovedReason())) + { + return egl::EglNotInitialized() << "Inputted D3D11 device has been lost."; + } + + if (d3dDevice->GetFeatureLevel() < D3D_FEATURE_LEVEL_9_3) + { + return egl::EglNotInitialized() + << "Inputted D3D11 device must be Feature Level 9_3 or greater."; + } + + // The Renderer11 adds a ref to the inputted D3D11 device, like D3D11CreateDevice does. + mDevice = d3dDevice; + mDevice->AddRef(); + mDevice->GetImmediateContext(&mDeviceContext); + mRenderer11DeviceCaps.featureLevel = mDevice->GetFeatureLevel(); + } + + mResourceManager11.setAllocationsInitialized(mCreateDebugDevice); + + d3d11::SetDebugName(mDeviceContext, "DeviceContext", nullptr); + + mAnnotatorContext.initialize(mDeviceContext); + + mDevice->QueryInterface(__uuidof(ID3D11Device1), reinterpret_cast<void **>(&mDevice1)); + + return egl::NoError(); +} + +void Renderer11::setGlobalDebugAnnotator() +{ + static angle::base::NoDestructor<std::mutex> gMutex; + static angle::base::NoDestructor<DebugAnnotator11> gGlobalAnnotator; + + std::lock_guard<std::mutex> lg(*gMutex); + gl::InitializeDebugAnnotations(gGlobalAnnotator.get()); +} + +// do any one-time device initialization +// NOTE: this is also needed after a device lost/reset +// to reset the scene status and ensure the default states are reset. +egl::Error Renderer11::initializeDevice() +{ + ANGLE_TRACE_EVENT0("gpu.angle", "Renderer11::initializeDevice"); + + populateRenderer11DeviceCaps(); + + mStateCache.clear(); + + ASSERT(!mBlit); + mBlit = new Blit11(this); + + ASSERT(!mClear); + mClear = new Clear11(this); + + const auto &attributes = mDisplay->getAttributeMap(); + // If automatic trim is enabled, DXGIDevice3::Trim( ) is called for the application + // automatically when an application is suspended by the OS. This feature is currently + // only supported for Windows Store applications. + EGLint enableAutoTrim = static_cast<EGLint>( + attributes.get(EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE, EGL_FALSE)); + + if (enableAutoTrim == EGL_TRUE) + { + ASSERT(!mTrim); + mTrim = new Trim11(this); + } + + ASSERT(!mPixelTransfer); + mPixelTransfer = new PixelTransfer11(this); + + // Gather stats on DXGI and D3D feature level + ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.SupportsDXGI1_2", mRenderer11DeviceCaps.supportsDXGI1_2); + + ANGLEFeatureLevel angleFeatureLevel = GetANGLEFeatureLevel(mRenderer11DeviceCaps.featureLevel); + + // We don't actually request a 11_1 device, because of complications with the platform + // update. Instead we check if the mDeviceContext1 pointer cast succeeded. + // Note: we should support D3D11_0 always, but we aren't guaranteed to be at FL11_0 + // because the app can specify a lower version (such as 9_3) on Display creation. + if (mDeviceContext1 != nullptr) + { + angleFeatureLevel = ANGLE_FEATURE_LEVEL_11_1; + } + + ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3D11FeatureLevel", angleFeatureLevel, + NUM_ANGLE_FEATURE_LEVELS); + + return egl::NoError(); +} + +void Renderer11::populateRenderer11DeviceCaps() +{ + HRESULT hr = S_OK; + + LARGE_INTEGER version; + hr = mDxgiAdapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &version); + if (FAILED(hr)) + { + mRenderer11DeviceCaps.driverVersion.reset(); + ERR() << "Error querying driver version from DXGI Adapter."; + } + else + { + mRenderer11DeviceCaps.driverVersion = version; + } + + if (mDeviceContext1) + { + D3D11_FEATURE_DATA_D3D11_OPTIONS d3d11Options; + HRESULT result = mDevice->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &d3d11Options, + sizeof(D3D11_FEATURE_DATA_D3D11_OPTIONS)); + if (SUCCEEDED(result)) + { + mRenderer11DeviceCaps.supportsClearView = (d3d11Options.ClearView != FALSE); + mRenderer11DeviceCaps.supportsConstantBufferOffsets = + (d3d11Options.ConstantBufferOffsetting != FALSE); + } + } + + if (mDeviceContext3) + { + D3D11_FEATURE_DATA_D3D11_OPTIONS3 d3d11Options3; + HRESULT result = mDevice->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS3, &d3d11Options3, + sizeof(D3D11_FEATURE_DATA_D3D11_OPTIONS3)); + if (SUCCEEDED(result)) + { + mRenderer11DeviceCaps.supportsVpRtIndexWriteFromVertexShader = + (d3d11Options3.VPAndRTArrayIndexFromAnyShaderFeedingRasterizer == TRUE); + } + D3D11_FEATURE_DATA_D3D11_OPTIONS2 d3d11Options2; + result = mDevice->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS2, &d3d11Options2, + sizeof(D3D11_FEATURE_DATA_D3D11_OPTIONS2)); + if (SUCCEEDED(result)) + { + mRenderer11DeviceCaps.supportsTypedUAVLoadAdditionalFormats = + d3d11Options2.TypedUAVLoadAdditionalFormats; + if (!getFeatures().disableRasterizerOrderViews.enabled) + { + mRenderer11DeviceCaps.supportsRasterizerOrderViews = d3d11Options2.ROVsSupported; + } + } + } + + mRenderer11DeviceCaps.supportsMultisampledDepthStencilSRVs = + mRenderer11DeviceCaps.featureLevel > D3D_FEATURE_LEVEL_10_0; + + if (getFeatures().disableB5G6R5Support.enabled) + { + mRenderer11DeviceCaps.B5G6R5support = 0; + mRenderer11DeviceCaps.B5G6R5maxSamples = 0; + } + else + { + PopulateFormatDeviceCaps(mDevice, DXGI_FORMAT_B5G6R5_UNORM, + &mRenderer11DeviceCaps.B5G6R5support, + &mRenderer11DeviceCaps.B5G6R5maxSamples); + } + + if (getFeatures().allowES3OnFL100.enabled) + { + mRenderer11DeviceCaps.allowES3OnFL10_0 = true; + } + + PopulateFormatDeviceCaps(mDevice, DXGI_FORMAT_B4G4R4A4_UNORM, + &mRenderer11DeviceCaps.B4G4R4A4support, + &mRenderer11DeviceCaps.B4G4R4A4maxSamples); + PopulateFormatDeviceCaps(mDevice, DXGI_FORMAT_B5G5R5A1_UNORM, + &mRenderer11DeviceCaps.B5G5R5A1support, + &mRenderer11DeviceCaps.B5G5R5A1maxSamples); + + IDXGIAdapter2 *dxgiAdapter2 = d3d11::DynamicCastComObject<IDXGIAdapter2>(mDxgiAdapter); + mRenderer11DeviceCaps.supportsDXGI1_2 = (dxgiAdapter2 != nullptr); + SafeRelease(dxgiAdapter2); +} + +gl::SupportedSampleSet Renderer11::generateSampleSetForEGLConfig( + const gl::TextureCaps &colorBufferFormatCaps, + const gl::TextureCaps &depthStencilBufferFormatCaps) const +{ + gl::SupportedSampleSet sampleCounts; + + // Generate a new set from the set intersection of sample counts between the color and depth + // format caps. + std::set_intersection(colorBufferFormatCaps.sampleCounts.begin(), + colorBufferFormatCaps.sampleCounts.end(), + depthStencilBufferFormatCaps.sampleCounts.begin(), + depthStencilBufferFormatCaps.sampleCounts.end(), + std::inserter(sampleCounts, sampleCounts.begin())); + + // Format of GL_NONE results in no supported sample counts. + // Add back the color sample counts to the supported sample set. + if (depthStencilBufferFormatCaps.sampleCounts.empty()) + { + sampleCounts = colorBufferFormatCaps.sampleCounts; + } + else if (colorBufferFormatCaps.sampleCounts.empty()) + { + // Likewise, add back the depth sample counts to the supported sample set. + sampleCounts = depthStencilBufferFormatCaps.sampleCounts; + } + + // Always support 0 samples + sampleCounts.insert(0); + + return sampleCounts; +} + +egl::ConfigSet Renderer11::generateConfigs() +{ + std::vector<GLenum> colorBufferFormats; + + // 32-bit supported formats + colorBufferFormats.push_back(GL_BGRA8_EXT); + colorBufferFormats.push_back(GL_RGBA8_OES); + + // 24-bit supported formats + colorBufferFormats.push_back(GL_RGB8_OES); + + if (mRenderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0) + { + // Additional high bit depth formats added in D3D 10.0 + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb173064.aspx + colorBufferFormats.push_back(GL_RGBA16F); + colorBufferFormats.push_back(GL_RGB10_A2); + } + + if (!mPresentPathFastEnabled) + { + // 16-bit supported formats + // These aren't valid D3D11 swapchain formats, so don't expose them as configs + // if present path fast is active + colorBufferFormats.push_back(GL_RGBA4); + colorBufferFormats.push_back(GL_RGB5_A1); + colorBufferFormats.push_back(GL_RGB565); + } + + static const GLenum depthStencilBufferFormats[] = { + GL_NONE, GL_DEPTH24_STENCIL8_OES, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16, + GL_STENCIL_INDEX8, + }; + + const gl::Caps &rendererCaps = getNativeCaps(); + const gl::TextureCapsMap &rendererTextureCaps = getNativeTextureCaps(); + + const EGLint optimalSurfaceOrientation = + mPresentPathFastEnabled ? 0 : EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE; + + egl::ConfigSet configs; + for (GLenum colorBufferInternalFormat : colorBufferFormats) + { + const gl::TextureCaps &colorBufferFormatCaps = + rendererTextureCaps.get(colorBufferInternalFormat); + if (!colorBufferFormatCaps.renderbuffer) + { + ASSERT(!colorBufferFormatCaps.textureAttachment); + continue; + } + + for (GLenum depthStencilBufferInternalFormat : depthStencilBufferFormats) + { + const gl::TextureCaps &depthStencilBufferFormatCaps = + rendererTextureCaps.get(depthStencilBufferInternalFormat); + if (!depthStencilBufferFormatCaps.renderbuffer && + depthStencilBufferInternalFormat != GL_NONE) + { + ASSERT(!depthStencilBufferFormatCaps.textureAttachment); + continue; + } + + const gl::InternalFormat &colorBufferFormatInfo = + gl::GetSizedInternalFormatInfo(colorBufferInternalFormat); + const gl::InternalFormat &depthStencilBufferFormatInfo = + gl::GetSizedInternalFormatInfo(depthStencilBufferInternalFormat); + const gl::Version &maxVersion = getMaxSupportedESVersion(); + + const gl::SupportedSampleSet sampleCounts = + generateSampleSetForEGLConfig(colorBufferFormatCaps, depthStencilBufferFormatCaps); + + for (GLuint sampleCount : sampleCounts) + { + egl::Config config; + config.renderTargetFormat = colorBufferInternalFormat; + config.depthStencilFormat = depthStencilBufferInternalFormat; + config.bufferSize = colorBufferFormatInfo.pixelBytes * 8; + config.redSize = colorBufferFormatInfo.redBits; + config.greenSize = colorBufferFormatInfo.greenBits; + config.blueSize = colorBufferFormatInfo.blueBits; + config.luminanceSize = colorBufferFormatInfo.luminanceBits; + config.alphaSize = colorBufferFormatInfo.alphaBits; + config.alphaMaskSize = 0; + config.bindToTextureRGB = + ((colorBufferFormatInfo.format == GL_RGB) && (sampleCount <= 1)); + config.bindToTextureRGBA = (((colorBufferFormatInfo.format == GL_RGBA) || + (colorBufferFormatInfo.format == GL_BGRA_EXT)) && + (sampleCount <= 1)); + config.colorBufferType = EGL_RGB_BUFFER; + config.configCaveat = EGL_NONE; + config.configID = static_cast<EGLint>(configs.size() + 1); + + // PresentPathFast may not be conformant + config.conformant = 0; + if (!mPresentPathFastEnabled) + { + // Can only support a conformant ES2 with feature level greater than 10.0. + if (mRenderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0) + { + config.conformant |= EGL_OPENGL_ES2_BIT; + } + + // We can only support conformant ES3 on FL 10.1+ + if (maxVersion.major >= 3) + { + config.conformant |= EGL_OPENGL_ES3_BIT_KHR; + } + } + + config.depthSize = depthStencilBufferFormatInfo.depthBits; + config.level = 0; + config.matchNativePixmap = EGL_NONE; + config.maxPBufferWidth = rendererCaps.max2DTextureSize; + config.maxPBufferHeight = rendererCaps.max2DTextureSize; + config.maxPBufferPixels = + rendererCaps.max2DTextureSize * rendererCaps.max2DTextureSize; + config.maxSwapInterval = 4; + config.minSwapInterval = 0; + config.nativeRenderable = EGL_FALSE; + config.nativeVisualID = 0; + config.nativeVisualType = EGL_NONE; + + // Can't support ES3 at all without feature level 10.1 + config.renderableType = EGL_OPENGL_ES2_BIT; + if (maxVersion.major >= 3) + { + config.renderableType |= EGL_OPENGL_ES3_BIT_KHR; + } + + config.sampleBuffers = (sampleCount == 0) ? 0 : 1; + config.samples = sampleCount; + config.stencilSize = depthStencilBufferFormatInfo.stencilBits; + config.surfaceType = + EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT; + config.transparentType = EGL_NONE; + config.transparentRedValue = 0; + config.transparentGreenValue = 0; + config.transparentBlueValue = 0; + config.optimalOrientation = optimalSurfaceOrientation; + config.colorComponentType = gl_egl::GLComponentTypeToEGLColorComponentType( + colorBufferFormatInfo.componentType); + + configs.add(config); + } + } + } + + ASSERT(configs.size() > 0); + return configs; +} + +void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const +{ + outExtensions->createContextRobustness = true; + + if (getShareHandleSupport()) + { + outExtensions->d3dShareHandleClientBuffer = true; + outExtensions->surfaceD3DTexture2DShareHandle = true; + } + outExtensions->d3dTextureClientBuffer = true; + outExtensions->imageD3D11Texture = true; + + outExtensions->keyedMutex = true; + outExtensions->querySurfacePointer = true; + outExtensions->windowFixedSize = true; + + // If present path fast is active then the surface orientation extension isn't supported + outExtensions->surfaceOrientation = !mPresentPathFastEnabled; + + // D3D11 does not support present with dirty rectangles until DXGI 1.2. + outExtensions->postSubBuffer = mRenderer11DeviceCaps.supportsDXGI1_2; + + outExtensions->image = true; + outExtensions->imageBase = true; + outExtensions->glTexture2DImage = true; + outExtensions->glTextureCubemapImage = true; + outExtensions->glRenderbufferImage = true; + + outExtensions->stream = true; + outExtensions->streamConsumerGLTexture = true; + outExtensions->streamConsumerGLTextureYUV = true; + outExtensions->streamProducerD3DTexture = true; + + outExtensions->noConfigContext = true; + outExtensions->directComposition = !!mDCompModule; + + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; + + // syncControlCHROMIUM requires direct composition. + outExtensions->syncControlCHROMIUM = outExtensions->directComposition; + + // D3D11 can be used without a swap chain + outExtensions->surfacelessContext = true; + + // All D3D feature levels support robust resource init + outExtensions->robustResourceInitializationANGLE = true; + +#ifdef ANGLE_ENABLE_D3D11_COMPOSITOR_NATIVE_WINDOW + // Compositor Native Window capabilies require WinVer >= 1803 + if (CompositorNativeWindow11::IsSupportedWinRelease()) + { + outExtensions->windowsUIComposition = true; + } +#endif +} + +angle::Result Renderer11::flush(Context11 *context11) +{ + mDeviceContext->Flush(); + return angle::Result::Continue; +} + +angle::Result Renderer11::finish(Context11 *context11) +{ + if (!mSyncQuery.valid()) + { + D3D11_QUERY_DESC queryDesc; + queryDesc.Query = D3D11_QUERY_EVENT; + queryDesc.MiscFlags = 0; + + ANGLE_TRY(allocateResource(context11, queryDesc, &mSyncQuery)); + } + + mDeviceContext->End(mSyncQuery.get()); + + HRESULT result = S_OK; + unsigned int attempt = 0; + do + { + unsigned int flushFrequency = 100; + UINT flags = (attempt % flushFrequency == 0) ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH; + attempt++; + + result = mDeviceContext->GetData(mSyncQuery.get(), nullptr, 0, flags); + ANGLE_TRY_HR(context11, result, "Failed to get event query data"); + + if (result == S_FALSE) + { + // Keep polling, but allow other threads to do something useful first + ScheduleYield(); + } + + // Attempt is incremented before checking if we should test for device loss so that device + // loss is not checked on the first iteration + bool checkDeviceLost = (attempt % kPollingD3DDeviceLostCheckFrequency) == 0; + if (checkDeviceLost && testDeviceLost()) + { + mDisplay->notifyDeviceLost(); + ANGLE_CHECK(context11, false, "Device was lost while waiting for sync.", + GL_OUT_OF_MEMORY); + } + } while (result == S_FALSE); + + return angle::Result::Continue; +} + +bool Renderer11::isValidNativeWindow(EGLNativeWindowType window) const +{ +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + if (NativeWindow11WinRT::IsValidNativeWindow(window)) + { + return true; + } +#else + if (NativeWindow11Win32::IsValidNativeWindow(window)) + { + return true; + } +#endif + +#ifdef ANGLE_ENABLE_D3D11_COMPOSITOR_NATIVE_WINDOW + static_assert(sizeof(ABI::Windows::UI::Composition::SpriteVisual *) == sizeof(HWND), + "Pointer size must match Window Handle size"); + if (CompositorNativeWindow11::IsValidNativeWindow(window)) + { + return true; + } +#endif + + return false; +} + +NativeWindowD3D *Renderer11::createNativeWindow(EGLNativeWindowType window, + const egl::Config *config, + const egl::AttributeMap &attribs) const +{ +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + if (window == nullptr || NativeWindow11WinRT::IsValidNativeWindow(window)) + { + return new NativeWindow11WinRT(window, config->alphaSize > 0); + } +#else + if (window == nullptr || NativeWindow11Win32::IsValidNativeWindow(window)) + { + return new NativeWindow11Win32( + window, config->alphaSize > 0, + attribs.get(EGL_DIRECT_COMPOSITION_ANGLE, EGL_FALSE) == EGL_TRUE); + } +#endif + +#ifdef ANGLE_ENABLE_D3D11_COMPOSITOR_NATIVE_WINDOW + if (CompositorNativeWindow11::IsValidNativeWindow(window)) + { + return new CompositorNativeWindow11(window, config->alphaSize > 0); + } +#endif + + UNREACHABLE(); + return nullptr; +} + +egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration, + IUnknown *texture, + const egl::AttributeMap &attribs, + EGLint *width, + EGLint *height, + GLsizei *samples, + gl::Format *glFormat, + const angle::Format **angleFormat, + UINT *arraySlice) const +{ + angle::ComPtr<ID3D11Texture2D> d3dTexture = + d3d11::DynamicCastComObjectToComPtr<ID3D11Texture2D>(texture); + if (d3dTexture == nullptr) + { + return egl::EglBadParameter() << "client buffer is not a ID3D11Texture2D"; + } + + angle::ComPtr<ID3D11Device> textureDevice; + d3dTexture->GetDevice(&textureDevice); + if (textureDevice.Get() != mDevice) + { + return egl::EglBadParameter() << "Texture's device does not match."; + } + + D3D11_TEXTURE2D_DESC desc = {}; + d3dTexture->GetDesc(&desc); + + EGLint imageWidth = static_cast<EGLint>(desc.Width); + EGLint imageHeight = static_cast<EGLint>(desc.Height); + + GLsizei sampleCount = static_cast<GLsizei>(desc.SampleDesc.Count); + if (configuration && (configuration->samples != sampleCount)) + { + // Both the texture and EGL config sample count may not be the same when multi-sampling + // is disabled. The EGL sample count can be 0 but a D3D texture is always 1. Therefore, + // we must only check for a invalid match when the EGL config is non-zero or the texture is + // not one. + if (configuration->samples != 0 || sampleCount != 1) + { + return egl::EglBadParameter() << "Texture's sample count does not match."; + } + } + + const angle::Format *textureAngleFormat = nullptr; + GLenum sizedInternalFormat = GL_NONE; + + // From table egl.restrictions in EGL_ANGLE_d3d_texture_client_buffer. + if (desc.Format == DXGI_FORMAT_NV12 || desc.Format == DXGI_FORMAT_P010 || + desc.Format == DXGI_FORMAT_P016) + { + if (!attribs.contains(EGL_D3D11_TEXTURE_PLANE_ANGLE)) + { + return egl::EglBadParameter() + << "EGL_D3D11_TEXTURE_PLANE_ANGLE must be specified for YUV textures."; + } + + EGLint plane = attribs.getAsInt(EGL_D3D11_TEXTURE_PLANE_ANGLE); + + // P010 and P016 have the same memory layout, SRV/RTV format, etc. + const bool isNV12 = (desc.Format == DXGI_FORMAT_NV12); + if (plane == 0) + { + textureAngleFormat = isNV12 ? &angle::Format::Get(angle::FormatID::R8_UNORM) + : &angle::Format::Get(angle::FormatID::R16_UNORM); + } + else if (plane == 1) + { + textureAngleFormat = isNV12 ? &angle::Format::Get(angle::FormatID::R8G8_UNORM) + : &angle::Format::Get(angle::FormatID::R16G16_UNORM); + imageWidth /= 2; + imageHeight /= 2; + } + else + { + return egl::EglBadParameter() << "Invalid client buffer texture plane: " << plane; + } + + ASSERT(textureAngleFormat); + sizedInternalFormat = textureAngleFormat->glInternalFormat; + } + else + { + switch (desc.Format) + { + case DXGI_FORMAT_R8G8B8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + case DXGI_FORMAT_R8G8B8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R32G32B32A32_FLOAT: + case DXGI_FORMAT_R10G10B10A2_UNORM: + case DXGI_FORMAT_R8_UNORM: + case DXGI_FORMAT_R8G8_UNORM: + case DXGI_FORMAT_R16_UNORM: + case DXGI_FORMAT_R16G16_UNORM: + break; + + default: + return egl::EglBadParameter() + << "Invalid client buffer texture format: " << desc.Format; + } + + textureAngleFormat = &d3d11_angle::GetFormat(desc.Format); + ASSERT(textureAngleFormat); + + sizedInternalFormat = textureAngleFormat->glInternalFormat; + + if (attribs.contains(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE)) + { + const GLenum internalFormat = + static_cast<GLenum>(attribs.get(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE)); + switch (internalFormat) + { + case GL_RGBA: + case GL_BGRA_EXT: + case GL_RGB: + case GL_RED_EXT: + case GL_RG_EXT: + case GL_RGB10_A2_EXT: + case GL_R16_EXT: + case GL_RG16_EXT: + break; + default: + return egl::EglBadParameter() + << "Invalid client buffer texture internal format: " << std::hex + << internalFormat; + } + + const GLenum type = gl::GetSizedInternalFormatInfo(sizedInternalFormat).type; + + const auto format = gl::Format(internalFormat, type); + if (!format.valid()) + { + return egl::EglBadParameter() + << "Invalid client buffer texture internal format: " << std::hex + << internalFormat; + } + + sizedInternalFormat = format.info->sizedInternalFormat; + } + } + + UINT textureArraySlice = + static_cast<UINT>(attribs.getAsInt(EGL_D3D11_TEXTURE_ARRAY_SLICE_ANGLE, 0)); + if (textureArraySlice >= desc.ArraySize) + { + return egl::EglBadParameter() + << "Invalid client buffer texture array slice: " << textureArraySlice; + } + + if (width) + { + *width = imageWidth; + } + if (height) + { + *height = imageHeight; + } + + if (samples) + { + // EGL samples 0 corresponds to D3D11 sample count 1. + *samples = sampleCount != 1 ? sampleCount : 0; + } + + if (glFormat) + { + *glFormat = gl::Format(sizedInternalFormat); + } + + if (angleFormat) + { + *angleFormat = textureAngleFormat; + } + + if (arraySlice) + { + *arraySlice = textureArraySlice; + } + + return egl::NoError(); +} + +egl::Error Renderer11::validateShareHandle(const egl::Config *config, + HANDLE shareHandle, + const egl::AttributeMap &attribs) const +{ + if (shareHandle == nullptr) + { + return egl::EglBadParameter() << "NULL share handle."; + } + + ID3D11Resource *tempResource11 = nullptr; + HRESULT result = mDevice->OpenSharedResource(shareHandle, __uuidof(ID3D11Resource), + (void **)&tempResource11); + if (FAILED(result) && mDevice1) + { + result = mDevice1->OpenSharedResource1(shareHandle, __uuidof(ID3D11Resource), + (void **)&tempResource11); + } + + if (FAILED(result)) + { + return egl::EglBadParameter() << "Failed to open share handle, " << gl::FmtHR(result); + } + + ID3D11Texture2D *texture2D = d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11); + SafeRelease(tempResource11); + + if (texture2D == nullptr) + { + return egl::EglBadParameter() + << "Failed to query ID3D11Texture2D object from share handle."; + } + + D3D11_TEXTURE2D_DESC desc = {}; + texture2D->GetDesc(&desc); + SafeRelease(texture2D); + + EGLint width = attribs.getAsInt(EGL_WIDTH, 0); + EGLint height = attribs.getAsInt(EGL_HEIGHT, 0); + ASSERT(width != 0 && height != 0); + + const d3d11::Format &backbufferFormatInfo = + d3d11::Format::Get(config->renderTargetFormat, getRenderer11DeviceCaps()); + + if (desc.Width != static_cast<UINT>(width) || desc.Height != static_cast<UINT>(height) || + desc.Format != backbufferFormatInfo.texFormat || desc.MipLevels != 1 || desc.ArraySize != 1) + { + return egl::EglBadParameter() << "Invalid texture parameters in share handle texture."; + } + + return egl::NoError(); +} + +SwapChainD3D *Renderer11::createSwapChain(NativeWindowD3D *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) +{ + return new SwapChain11(this, GetAs<NativeWindow11>(nativeWindow), shareHandle, d3dTexture, + backBufferFormat, depthBufferFormat, orientation, samples); +} + +void *Renderer11::getD3DDevice() +{ + return mDevice; +} + +angle::Result Renderer11::drawWithGeometryShaderAndTransformFeedback(Context11 *context11, + gl::PrimitiveMode mode, + UINT instanceCount, + UINT vertexCount) +{ + const gl::State &glState = context11->getState(); + ProgramD3D *programD3D = mStateManager.getProgramD3D(); + + // Since we use a geometry if-and-only-if we rewrite vertex streams, transform feedback + // won't get the correct output. To work around this, draw with *only* the stream out + // first (no pixel shader) to feed the stream out buffers and then draw again with the + // geometry shader + pixel shader to rasterize the primitives. + mStateManager.setPixelShader(nullptr); + + if (instanceCount > 0) + { + mDeviceContext->DrawInstanced(vertexCount, instanceCount, 0, 0); + } + else + { + mDeviceContext->Draw(vertexCount, 0); + } + + rx::ShaderExecutableD3D *pixelExe = nullptr; + ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(context11, &pixelExe, nullptr)); + + // Skip the draw call if rasterizer discard is enabled (or no fragment shader). + if (!pixelExe || glState.getRasterizerState().rasterizerDiscard) + { + return angle::Result::Continue; + } + + mStateManager.setPixelShader(&GetAs<ShaderExecutable11>(pixelExe)->getPixelShader()); + + // Retrieve the geometry shader. + rx::ShaderExecutableD3D *geometryExe = nullptr; + ANGLE_TRY(programD3D->getGeometryExecutableForPrimitiveType(context11, glState, mode, + &geometryExe, nullptr)); + + mStateManager.setGeometryShader(&GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader()); + + if (instanceCount > 0) + { + mDeviceContext->DrawInstanced(vertexCount, instanceCount, 0, 0); + } + else + { + mDeviceContext->Draw(vertexCount, 0); + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexCount, + GLsizei instanceCount, + GLuint baseInstance, + bool isInstancedDraw) +{ + if (mStateManager.getCullEverything()) + { + return angle::Result::Continue; + } + + ANGLE_TRY(markRawBufferUsage(context)); + + ProgramD3D *programD3D = mStateManager.getProgramD3D(); + GLsizei adjustedInstanceCount = GetAdjustedInstanceCount(programD3D, instanceCount); + + // Note: vertex indexes can be arbitrarily large. + UINT clampedVertexCount = gl::GetClampedVertexCount<UINT>(vertexCount); + + const auto &glState = context->getState(); + if (glState.getCurrentTransformFeedback() && glState.isTransformFeedbackActiveUnpaused()) + { + ANGLE_TRY(markTransformFeedbackUsage(context)); + + if (programD3D->usesGeometryShader(glState, mode)) + { + return drawWithGeometryShaderAndTransformFeedback( + GetImplAs<Context11>(context), mode, adjustedInstanceCount, clampedVertexCount); + } + } + + switch (mode) + { + case gl::PrimitiveMode::LineLoop: + return drawLineLoop(context, clampedVertexCount, gl::DrawElementsType::InvalidEnum, + nullptr, 0, adjustedInstanceCount); + case gl::PrimitiveMode::TriangleFan: + return drawTriangleFan(context, clampedVertexCount, gl::DrawElementsType::InvalidEnum, + nullptr, 0, adjustedInstanceCount); + case gl::PrimitiveMode::Points: + if (getFeatures().useInstancedPointSpriteEmulation.enabled) + { + // This code should not be reachable by multi-view programs. + ASSERT(programD3D->getState().usesMultiview() == false); + + // If the shader is writing to gl_PointSize, then pointsprites are being rendered. + // Emulating instanced point sprites for FL9_3 requires the topology to be + // D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST and DrawIndexedInstanced is called instead. + if (adjustedInstanceCount == 0) + { + mDeviceContext->DrawIndexedInstanced(6, clampedVertexCount, 0, 0, baseInstance); + return angle::Result::Continue; + } + + // If pointsprite emulation is used with glDrawArraysInstanced then we need to take + // a less efficent code path. Instanced rendering of emulated pointsprites requires + // a loop to draw each batch of points. An offset into the instanced data buffer is + // calculated and applied on each iteration to ensure all instances are rendered + // correctly. Each instance being rendered requires the inputlayout cache to reapply + // buffers and offsets. + for (GLsizei i = 0; i < instanceCount; i++) + { + ANGLE_TRY(mStateManager.updateVertexOffsetsForPointSpritesEmulation( + context, firstVertex, i)); + mDeviceContext->DrawIndexedInstanced(6, clampedVertexCount, 0, 0, baseInstance); + } + + // This required by updateVertexOffsets... above but is outside of the loop for + // speed. + mStateManager.invalidateVertexBuffer(); + return angle::Result::Continue; + } + break; + default: + break; + } + + // "Normal" draw case. + if (!isInstancedDraw && adjustedInstanceCount == 0) + { + mDeviceContext->Draw(clampedVertexCount, 0); + } + else + { + mDeviceContext->DrawInstanced(clampedVertexCount, adjustedInstanceCount, 0, baseInstance); + } + return angle::Result::Continue; +} + +angle::Result Renderer11::drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLint startVertex, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool isInstancedDraw) +{ + if (mStateManager.getCullEverything()) + { + return angle::Result::Continue; + } + + ANGLE_TRY(markRawBufferUsage(context)); + + // Transform feedback is not allowed for DrawElements, this error should have been caught at the + // API validation layer. + const gl::State &glState = context->getState(); + ASSERT(!glState.isTransformFeedbackActiveUnpaused()); + + // If this draw call is coming from an indirect call, offset by the indirect call's base vertex. + GLint baseVertexAdjusted = baseVertex - startVertex; + + const ProgramD3D *programD3D = mStateManager.getProgramD3D(); + GLsizei adjustedInstanceCount = GetAdjustedInstanceCount(programD3D, instanceCount); + + if (mode == gl::PrimitiveMode::LineLoop) + { + return drawLineLoop(context, indexCount, indexType, indices, baseVertexAdjusted, + adjustedInstanceCount); + } + + if (mode == gl::PrimitiveMode::TriangleFan) + { + return drawTriangleFan(context, indexCount, indexType, indices, baseVertexAdjusted, + adjustedInstanceCount); + } + + if (mode != gl::PrimitiveMode::Points || !programD3D->usesInstancedPointSpriteEmulation()) + { + if (!isInstancedDraw && adjustedInstanceCount == 0) + { + mDeviceContext->DrawIndexed(indexCount, 0, baseVertexAdjusted); + } + else + { + mDeviceContext->DrawIndexedInstanced(indexCount, adjustedInstanceCount, 0, + baseVertexAdjusted, baseInstance); + } + return angle::Result::Continue; + } + + // This code should not be reachable by multi-view programs. + ASSERT(programD3D->getState().usesMultiview() == false); + + // If the shader is writing to gl_PointSize, then pointsprites are being rendered. + // Emulating instanced point sprites for FL9_3 requires the topology to be + // D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST and DrawIndexedInstanced is called instead. + // + // The count parameter passed to drawElements represents the total number of instances to be + // rendered. Each instance is referenced by the bound index buffer from the the caller. + // + // Indexed pointsprite emulation replicates data for duplicate entries found in the index + // buffer. This is not an efficent rendering mechanism and is only used on downlevel renderers + // that do not support geometry shaders. + if (instanceCount == 0) + { + mDeviceContext->DrawIndexedInstanced(6, indexCount, 0, baseVertexAdjusted, baseInstance); + return angle::Result::Continue; + } + + // If pointsprite emulation is used with glDrawElementsInstanced then we need to take a less + // efficent code path. Instanced rendering of emulated pointsprites requires a loop to draw each + // batch of points. An offset into the instanced data buffer is calculated and applied on each + // iteration to ensure all instances are rendered correctly. + gl::IndexRange indexRange; + ANGLE_TRY(glState.getVertexArray()->getIndexRange(context, indexType, indexCount, indices, + &indexRange)); + + UINT clampedVertexCount = gl::clampCast<UINT>(indexRange.vertexCount()); + + // Each instance being rendered requires the inputlayout cache to reapply buffers and offsets. + for (GLsizei i = 0; i < instanceCount; i++) + { + ANGLE_TRY( + mStateManager.updateVertexOffsetsForPointSpritesEmulation(context, startVertex, i)); + mDeviceContext->DrawIndexedInstanced(6, clampedVertexCount, 0, baseVertexAdjusted, + baseInstance); + } + mStateManager.invalidateVertexBuffer(); + return angle::Result::Continue; +} + +angle::Result Renderer11::drawArraysIndirect(const gl::Context *context, const void *indirect) +{ + if (mStateManager.getCullEverything()) + { + return angle::Result::Continue; + } + + ANGLE_TRY(markRawBufferUsage(context)); + + const gl::State &glState = context->getState(); + ASSERT(!glState.isTransformFeedbackActiveUnpaused()); + + gl::Buffer *drawIndirectBuffer = glState.getTargetBuffer(gl::BufferBinding::DrawIndirect); + ASSERT(drawIndirectBuffer); + Buffer11 *storage = GetImplAs<Buffer11>(drawIndirectBuffer); + + uintptr_t offset = reinterpret_cast<uintptr_t>(indirect); + + ID3D11Buffer *buffer = nullptr; + ANGLE_TRY(storage->getBuffer(context, BUFFER_USAGE_INDIRECT, &buffer)); + mDeviceContext->DrawInstancedIndirect(buffer, static_cast<unsigned int>(offset)); + return angle::Result::Continue; +} + +angle::Result Renderer11::drawElementsIndirect(const gl::Context *context, const void *indirect) +{ + if (mStateManager.getCullEverything()) + { + return angle::Result::Continue; + } + + ANGLE_TRY(markRawBufferUsage(context)); + + const gl::State &glState = context->getState(); + ASSERT(!glState.isTransformFeedbackActiveUnpaused()); + + gl::Buffer *drawIndirectBuffer = glState.getTargetBuffer(gl::BufferBinding::DrawIndirect); + ASSERT(drawIndirectBuffer); + Buffer11 *storage = GetImplAs<Buffer11>(drawIndirectBuffer); + uintptr_t offset = reinterpret_cast<uintptr_t>(indirect); + + ID3D11Buffer *buffer = nullptr; + ANGLE_TRY(storage->getBuffer(context, BUFFER_USAGE_INDIRECT, &buffer)); + mDeviceContext->DrawIndexedInstancedIndirect(buffer, static_cast<unsigned int>(offset)); + return angle::Result::Continue; +} + +angle::Result Renderer11::drawLineLoop(const gl::Context *context, + GLuint count, + gl::DrawElementsType type, + const void *indexPointer, + int baseVertex, + int instances) +{ + const gl::State &glState = context->getState(); + gl::VertexArray *vao = glState.getVertexArray(); + gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer(); + + const void *indices = indexPointer; + + // Get the raw indices for an indexed draw + if (type != gl::DrawElementsType::InvalidEnum && elementArrayBuffer) + { + BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer); + intptr_t offset = reinterpret_cast<intptr_t>(indices); + + const uint8_t *bufferData = nullptr; + ANGLE_TRY(storage->getData(context, &bufferData)); + + indices = bufferData + offset; + } + + if (!mLineLoopIB) + { + mLineLoopIB = new StreamingIndexBufferInterface(this); + ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE, + gl::DrawElementsType::UnsignedInt)); + } + + // Checked by Renderer11::applyPrimitiveType + bool indexCheck = static_cast<unsigned int>(count) + 1 > + (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)); + ANGLE_CHECK(GetImplAs<Context11>(context), !indexCheck, + "Failed to create a 32-bit looping index buffer for " + "GL_LINE_LOOP, too many indices required.", + GL_OUT_OF_MEMORY); + + GetLineLoopIndices(indices, type, static_cast<GLuint>(count), + glState.isPrimitiveRestartEnabled(), &mScratchIndexDataBuffer); + + unsigned int spaceNeeded = + static_cast<unsigned int>(sizeof(GLuint) * mScratchIndexDataBuffer.size()); + ANGLE_TRY( + mLineLoopIB->reserveBufferSpace(context, spaceNeeded, gl::DrawElementsType::UnsignedInt)); + + void *mappedMemory = nullptr; + unsigned int offset; + ANGLE_TRY(mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset)); + + // Copy over the converted index data. + memcpy(mappedMemory, &mScratchIndexDataBuffer[0], + sizeof(GLuint) * mScratchIndexDataBuffer.size()); + + ANGLE_TRY(mLineLoopIB->unmapBuffer(context)); + + IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(mLineLoopIB->getIndexBuffer()); + const d3d11::Buffer &d3dIndexBuffer = indexBuffer->getBuffer(); + DXGI_FORMAT indexFormat = indexBuffer->getIndexFormat(); + + mStateManager.setIndexBuffer(d3dIndexBuffer.get(), indexFormat, offset); + + UINT indexCount = static_cast<UINT>(mScratchIndexDataBuffer.size()); + + if (instances > 0) + { + mDeviceContext->DrawIndexedInstanced(indexCount, instances, 0, baseVertex, 0); + } + else + { + mDeviceContext->DrawIndexed(indexCount, 0, baseVertex); + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::drawTriangleFan(const gl::Context *context, + GLuint count, + gl::DrawElementsType type, + const void *indices, + int baseVertex, + int instances) +{ + const gl::State &glState = context->getState(); + gl::VertexArray *vao = glState.getVertexArray(); + gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer(); + + const void *indexPointer = indices; + + // Get the raw indices for an indexed draw + if (type != gl::DrawElementsType::InvalidEnum && elementArrayBuffer) + { + BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer); + intptr_t offset = reinterpret_cast<intptr_t>(indices); + + const uint8_t *bufferData = nullptr; + ANGLE_TRY(storage->getData(context, &bufferData)); + + indexPointer = bufferData + offset; + } + + if (!mTriangleFanIB) + { + mTriangleFanIB = new StreamingIndexBufferInterface(this); + ANGLE_TRY(mTriangleFanIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE, + gl::DrawElementsType::UnsignedInt)); + } + + // Checked by Renderer11::applyPrimitiveType + ASSERT(count >= 3); + + const GLuint numTris = count - 2; + + bool indexCheck = + (numTris > std::numeric_limits<unsigned int>::max() / (sizeof(unsigned int) * 3)); + ANGLE_CHECK(GetImplAs<Context11>(context), !indexCheck, + "Failed to create a scratch index buffer for GL_TRIANGLE_FAN, " + "too many indices required.", + GL_OUT_OF_MEMORY); + + GetTriFanIndices(indexPointer, type, count, glState.isPrimitiveRestartEnabled(), + &mScratchIndexDataBuffer); + + const unsigned int spaceNeeded = + static_cast<unsigned int>(mScratchIndexDataBuffer.size() * sizeof(unsigned int)); + ANGLE_TRY(mTriangleFanIB->reserveBufferSpace(context, spaceNeeded, + gl::DrawElementsType::UnsignedInt)); + + void *mappedMemory = nullptr; + unsigned int offset; + ANGLE_TRY(mTriangleFanIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset)); + + memcpy(mappedMemory, &mScratchIndexDataBuffer[0], spaceNeeded); + + ANGLE_TRY(mTriangleFanIB->unmapBuffer(context)); + + IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(mTriangleFanIB->getIndexBuffer()); + const d3d11::Buffer &d3dIndexBuffer = indexBuffer->getBuffer(); + DXGI_FORMAT indexFormat = indexBuffer->getIndexFormat(); + + mStateManager.setIndexBuffer(d3dIndexBuffer.get(), indexFormat, offset); + + UINT indexCount = static_cast<UINT>(mScratchIndexDataBuffer.size()); + + if (instances > 0) + { + mDeviceContext->DrawIndexedInstanced(indexCount, instances, 0, baseVertex, 0); + } + else + { + mDeviceContext->DrawIndexed(indexCount, 0, baseVertex); + } + + return angle::Result::Continue; +} + +void Renderer11::releaseDeviceResources() +{ + mStateManager.deinitialize(); + mStateCache.clear(); + + SafeDelete(mLineLoopIB); + SafeDelete(mTriangleFanIB); + SafeDelete(mBlit); + SafeDelete(mClear); + SafeDelete(mTrim); + SafeDelete(mPixelTransfer); + + mSyncQuery.reset(); + + mCachedResolveTexture.reset(); +} + +// set notify to true to broadcast a message to all contexts of the device loss +bool Renderer11::testDeviceLost() +{ + if (!mDevice) + { + return true; + } + + // GetRemovedReason is used to test if the device is removed + HRESULT result = mDevice->GetDeviceRemovedReason(); + bool isLost = FAILED(result); + + if (isLost) + { + ERR() << "The D3D11 device was removed, " << gl::FmtHR(result); + } + + return isLost; +} + +bool Renderer11::testDeviceResettable() +{ + // determine if the device is resettable by creating a mock device + PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = + (PFN_D3D11_CREATE_DEVICE)GetProcAddress(mD3d11Module, "D3D11CreateDevice"); + + if (D3D11CreateDevice == nullptr) + { + return false; + } + + ID3D11Device *mockDevice; + D3D_FEATURE_LEVEL mockFeatureLevel; + ID3D11DeviceContext *mockContext; + UINT flags = (mCreateDebugDevice ? D3D11_CREATE_DEVICE_DEBUG : 0); + + ASSERT(mRequestedDriverType != D3D_DRIVER_TYPE_UNKNOWN); + HRESULT result = D3D11CreateDevice( + nullptr, mRequestedDriverType, nullptr, flags, mAvailableFeatureLevels.data(), + static_cast<unsigned int>(mAvailableFeatureLevels.size()), D3D11_SDK_VERSION, &mockDevice, + &mockFeatureLevel, &mockContext); + + if (!mDevice || FAILED(result)) + { + return false; + } + + SafeRelease(mockContext); + SafeRelease(mockDevice); + + return true; +} + +void Renderer11::release() +{ + mScratchMemoryBuffer.clear(); + + mAnnotatorContext.release(); + gl::UninitializeDebugAnnotations(); + + releaseDeviceResources(); + + SafeRelease(mDxgiFactory); + SafeRelease(mDxgiAdapter); + + SafeRelease(mDeviceContext3); + SafeRelease(mDeviceContext1); + + if (mDeviceContext) + { + mDeviceContext->ClearState(); + mDeviceContext->Flush(); + SafeRelease(mDeviceContext); + } + + SafeRelease(mDevice); + SafeRelease(mDevice1); + SafeRelease(mDebug); + + if (mD3d11Module) + { + FreeLibrary(mD3d11Module); + mD3d11Module = nullptr; + } + + if (mDxgiModule) + { + FreeLibrary(mDxgiModule); + mDxgiModule = nullptr; + } + + if (mDCompModule) + { + FreeLibrary(mDCompModule); + mDCompModule = nullptr; + } + + mDevice12.Reset(); + mCommandQueue.Reset(); + + if (mD3d12Module) + { + FreeLibrary(mD3d12Module); + mD3d12Module = nullptr; + } + + mCompiler.release(); + + mSupportsShareHandles.reset(); +} + +bool Renderer11::resetDevice() +{ + // recreate everything + release(); + egl::Error result = initialize(); + + if (result.isError()) + { + ERR() << "Could not reinitialize D3D11 device: " << result; + return false; + } + + return true; +} + +std::string Renderer11::getRendererDescription() const +{ + std::ostringstream rendererString; + + rendererString << mDescription; + rendererString << " Direct3D11"; + + rendererString << " vs_" << getMajorShaderModel() << "_" << getMinorShaderModel() + << getShaderModelSuffix(); + rendererString << " ps_" << getMajorShaderModel() << "_" << getMinorShaderModel() + << getShaderModelSuffix(); + + return rendererString.str(); +} + +DeviceIdentifier Renderer11::getAdapterIdentifier() const +{ + // Don't use the AdapterLuid here, since that doesn't persist across reboot. + DeviceIdentifier deviceIdentifier = {}; + deviceIdentifier.VendorId = mAdapterDescription.VendorId; + deviceIdentifier.DeviceId = mAdapterDescription.DeviceId; + deviceIdentifier.SubSysId = mAdapterDescription.SubSysId; + deviceIdentifier.Revision = mAdapterDescription.Revision; + deviceIdentifier.FeatureLevel = static_cast<UINT>(mRenderer11DeviceCaps.featureLevel); + + return deviceIdentifier; +} + +unsigned int Renderer11::getReservedVertexUniformVectors() const +{ + // Driver uniforms are stored in a separate constant buffer + return d3d11_gl::GetReservedVertexUniformVectors(mRenderer11DeviceCaps.featureLevel); +} + +unsigned int Renderer11::getReservedFragmentUniformVectors() const +{ + // Driver uniforms are stored in a separate constant buffer + return d3d11_gl::GetReservedFragmentUniformVectors(mRenderer11DeviceCaps.featureLevel); +} + +gl::ShaderMap<unsigned int> Renderer11::getReservedShaderUniformBuffers() const +{ + gl::ShaderMap<unsigned int> shaderReservedUniformBuffers = {}; + + // we reserve one buffer for the application uniforms, and one for driver uniforms + shaderReservedUniformBuffers[gl::ShaderType::Vertex] = 2; + shaderReservedUniformBuffers[gl::ShaderType::Fragment] = 2; + + return shaderReservedUniformBuffers; +} + +d3d11::ANGLED3D11DeviceType Renderer11::getDeviceType() const +{ + if (mCreatedWithDeviceEXT) + { + return d3d11::GetDeviceType(mDevice); + } + + if ((mRequestedDriverType == D3D_DRIVER_TYPE_SOFTWARE) || + (mRequestedDriverType == D3D_DRIVER_TYPE_REFERENCE) || + (mRequestedDriverType == D3D_DRIVER_TYPE_NULL)) + { + return d3d11::ANGLE_D3D11_DEVICE_TYPE_SOFTWARE_REF_OR_NULL; + } + + if (mRequestedDriverType == D3D_DRIVER_TYPE_WARP) + { + return d3d11::ANGLE_D3D11_DEVICE_TYPE_WARP; + } + + return d3d11::ANGLE_D3D11_DEVICE_TYPE_HARDWARE; +} + +bool Renderer11::getShareHandleSupport() const +{ + if (mSupportsShareHandles.valid()) + { + return mSupportsShareHandles.value(); + } + + // We only currently support share handles with BGRA surfaces, because + // chrome needs BGRA. Once chrome fixes this, we should always support them. + if (!getNativeExtensions().textureFormatBGRA8888EXT) + { + mSupportsShareHandles = false; + return false; + } + + // PIX doesn't seem to support using share handles, so disable them. + if (mAnnotatorContext.getStatus()) + { + mSupportsShareHandles = false; + return false; + } + + // Also disable share handles on Feature Level 9_3, since it doesn't support share handles on + // RGBA8 textures/swapchains. + if (mRenderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + mSupportsShareHandles = false; + return false; + } + + // Find out which type of D3D11 device the Renderer11 is using + d3d11::ANGLED3D11DeviceType deviceType = getDeviceType(); + if (deviceType == d3d11::ANGLE_D3D11_DEVICE_TYPE_UNKNOWN) + { + mSupportsShareHandles = false; + return false; + } + + if (deviceType == d3d11::ANGLE_D3D11_DEVICE_TYPE_SOFTWARE_REF_OR_NULL) + { + // Software/Reference/NULL devices don't support share handles + mSupportsShareHandles = false; + return false; + } + + if (deviceType == d3d11::ANGLE_D3D11_DEVICE_TYPE_WARP) + { +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + if (!IsWindows8OrGreater()) + { + // WARP on Windows 7 doesn't support shared handles + mSupportsShareHandles = false; + return false; + } +#endif // !defined(ANGLE_ENABLE_WINDOWS_UWP) + + // WARP on Windows 8.0+ supports shared handles when shared with another WARP device + // TODO: allow applications to query for HARDWARE or WARP-specific share handles, + // to prevent them trying to use a WARP share handle with an a HW device (or + // vice-versa) + // e.g. by creating EGL_D3D11_[HARDWARE/WARP]_DEVICE_SHARE_HANDLE_ANGLE + mSupportsShareHandles = true; + return true; + } + + ASSERT(mCreatedWithDeviceEXT || mRequestedDriverType == D3D_DRIVER_TYPE_HARDWARE); + mSupportsShareHandles = true; + return true; +} + +int Renderer11::getMajorShaderModel() const +{ + switch (mRenderer11DeviceCaps.featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_SHADER_MAJOR_VERSION; // 5 + case D3D_FEATURE_LEVEL_10_1: + return D3D10_1_SHADER_MAJOR_VERSION; // 4 + case D3D_FEATURE_LEVEL_10_0: + return D3D10_SHADER_MAJOR_VERSION; // 4 + case D3D_FEATURE_LEVEL_9_3: + return D3D10_SHADER_MAJOR_VERSION; // 4 + default: + UNREACHABLE(); + return 0; + } +} + +int Renderer11::getMinorShaderModel() const +{ + switch (mRenderer11DeviceCaps.featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_SHADER_MINOR_VERSION; // 0 + case D3D_FEATURE_LEVEL_10_1: + return D3D10_1_SHADER_MINOR_VERSION; // 1 + case D3D_FEATURE_LEVEL_10_0: + return D3D10_SHADER_MINOR_VERSION; // 0 + case D3D_FEATURE_LEVEL_9_3: + return D3D10_SHADER_MINOR_VERSION; // 0 + default: + UNREACHABLE(); + return 0; + } +} + +std::string Renderer11::getShaderModelSuffix() const +{ + switch (mRenderer11DeviceCaps.featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return ""; + case D3D_FEATURE_LEVEL_10_1: + return ""; + case D3D_FEATURE_LEVEL_10_0: + return ""; + case D3D_FEATURE_LEVEL_9_3: + return "_level_9_3"; + default: + UNREACHABLE(); + return ""; + } +} + +angle::Result Renderer11::copyImageInternal(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + RenderTargetD3D *destRenderTarget) +{ + const gl::FramebufferAttachment *colorAttachment = framebuffer->getReadColorAttachment(); + ASSERT(colorAttachment); + + RenderTarget11 *sourceRenderTarget = nullptr; + ANGLE_TRY(colorAttachment->getRenderTarget(context, 0, &sourceRenderTarget)); + ASSERT(sourceRenderTarget); + + const d3d11::RenderTargetView &dest = + GetAs<RenderTarget11>(destRenderTarget)->getRenderTargetView(); + ASSERT(dest.valid()); + + gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1); + gl::Extents sourceSize(sourceRenderTarget->getWidth(), sourceRenderTarget->getHeight(), 1); + + const bool invertSource = UsePresentPathFast(this, colorAttachment); + if (invertSource) + { + sourceArea.y = sourceSize.height - sourceRect.y; + sourceArea.height = -sourceArea.height; + } + + gl::Box destArea(destOffset.x, destOffset.y, 0, sourceRect.width, sourceRect.height, 1); + gl::Extents destSize(destRenderTarget->getWidth(), destRenderTarget->getHeight(), 1); + + // Use nearest filtering because source and destination are the same size for the direct copy. + // Convert to the unsized format before calling copyTexture. + GLenum sourceFormat = colorAttachment->getFormat().info->format; + if (sourceRenderTarget->getTexture().is2D() && sourceRenderTarget->isMultisampled()) + { + TextureHelper11 tex; + ANGLE_TRY(resolveMultisampledTexture(context, sourceRenderTarget, + colorAttachment->getDepthSize() > 0, + colorAttachment->getStencilSize() > 0, &tex)); + + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = sourceRenderTarget->getFormatSet().srvFormat; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + viewDesc.Texture2D.MipLevels = 1; + viewDesc.Texture2D.MostDetailedMip = 0; + + d3d11::SharedSRV readSRV; + ANGLE_TRY(allocateResource(GetImplAs<Context11>(context), viewDesc, tex.get(), &readSRV)); + ASSERT(readSRV.valid()); + + ANGLE_TRY(mBlit->copyTexture(context, readSRV, sourceArea, sourceSize, sourceFormat, dest, + destArea, destSize, nullptr, gl::GetUnsizedFormat(destFormat), + GL_NONE, GL_NEAREST, false, false, false)); + + return angle::Result::Continue; + } + + ASSERT(!sourceRenderTarget->isMultisampled()); + + const d3d11::SharedSRV *source; + ANGLE_TRY(sourceRenderTarget->getBlitShaderResourceView(context, &source)); + ASSERT(source->valid()); + + ANGLE_TRY(mBlit->copyTexture(context, *source, sourceArea, sourceSize, sourceFormat, dest, + destArea, destSize, nullptr, gl::GetUnsizedFormat(destFormat), + GL_NONE, GL_NEAREST, false, false, false)); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyImage2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + TextureStorage11_2D *storage11 = GetAs<TextureStorage11_2D>(storage); + ASSERT(storage11); + + gl::ImageIndex index = gl::ImageIndex::Make2D(level); + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(storage11->getRenderTarget(context, index, storage11->getRenderToTextureSamples(), + &destRenderTarget)); + ASSERT(destRenderTarget); + + ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset, + destRenderTarget)); + + storage11->markLevelDirty(level); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyImageCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) +{ + TextureStorage11_Cube *storage11 = GetAs<TextureStorage11_Cube>(storage); + ASSERT(storage11); + + gl::ImageIndex index = gl::ImageIndex::MakeCubeMapFace(target, level); + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(storage11->getRenderTarget(context, index, storage11->getRenderToTextureSamples(), + &destRenderTarget)); + ASSERT(destRenderTarget); + + ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset, + destRenderTarget)); + + storage11->markLevelDirty(level); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyImage3D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + TextureStorage11_3D *storage11 = GetAs<TextureStorage11_3D>(storage); + ASSERT(storage11); + + gl::ImageIndex index = gl::ImageIndex::Make3D(level, destOffset.z); + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(storage11->getRenderTarget(context, index, storage11->getRenderToTextureSamples(), + &destRenderTarget)); + ASSERT(destRenderTarget); + + ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset, + destRenderTarget)); + + storage11->markLevelDirty(level); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyImage2DArray(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + TextureStorage11_2DArray *storage11 = GetAs<TextureStorage11_2DArray>(storage); + ASSERT(storage11); + + gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, destOffset.z); + RenderTargetD3D *destRenderTarget = nullptr; + ANGLE_TRY(storage11->getRenderTarget(context, index, storage11->getRenderToTextureSamples(), + &destRenderTarget)); + ASSERT(destRenderTarget); + + ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset, + destRenderTarget)); + storage11->markLevelDirty(level); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + gl::TextureTarget srcTarget, + const gl::Box &sourceBox, + GLenum destFormat, + GLenum destType, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + const gl::ImageDesc &sourceImageDesc = source->getTextureState().getImageDesc( + NonCubeTextureTypeToTarget(source->getType()), sourceLevel); + + TextureStorage11 *destStorage11 = GetAs<TextureStorage11>(storage); + ASSERT(destStorage11); + + // Check for fast path where a CopySubresourceRegion can be used. + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha && !unpackFlipY && + sourceImageDesc.format.info->sizedInternalFormat == + destStorage11->getFormatSet().internalFormat) + { + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(destStorage11->getResource(context, &destResource)); + + if (srcTarget == gl::TextureTarget::_2D || srcTarget == gl::TextureTarget::_3D) + { + gl::ImageIndex sourceIndex = gl::ImageIndex::MakeFromTarget(srcTarget, sourceLevel, 1); + const TextureHelper11 *sourceResource = nullptr; + UINT sourceSubresource = 0; + ANGLE_TRY(GetTextureD3DResourceFromStorageOrImage(context, sourceD3D, sourceIndex, + &sourceResource, &sourceSubresource)); + + gl::ImageIndex destIndex = gl::ImageIndex::MakeFromTarget(destTarget, destLevel, 1); + + UINT destSubresource = 0; + ANGLE_TRY(destStorage11->getSubresourceIndex(context, destIndex, &destSubresource)); + + D3D11_BOX d3dBox{static_cast<UINT>(sourceBox.x), + static_cast<UINT>(sourceBox.y), + static_cast<UINT>(sourceBox.z), + static_cast<UINT>(sourceBox.x + sourceBox.width), + static_cast<UINT>(sourceBox.y + sourceBox.height), + static_cast<UINT>(sourceBox.z + sourceBox.depth)}; + + mDeviceContext->CopySubresourceRegion( + destResource->get(), destSubresource, destOffset.x, destOffset.y, destOffset.z, + sourceResource->get(), sourceSubresource, &d3dBox); + } + else if (srcTarget == gl::TextureTarget::_2DArray) + { + D3D11_BOX d3dBox{static_cast<UINT>(sourceBox.x), + static_cast<UINT>(sourceBox.y), + 0, + static_cast<UINT>(sourceBox.x + sourceBox.width), + static_cast<UINT>(sourceBox.y + sourceBox.height), + 1u}; + + for (int i = 0; i < sourceBox.depth; i++) + { + gl::ImageIndex sourceIndex = + gl::ImageIndex::Make2DArray(sourceLevel, i + sourceBox.z); + const TextureHelper11 *sourceResource = nullptr; + UINT sourceSubresource = 0; + ANGLE_TRY(GetTextureD3DResourceFromStorageOrImage( + context, sourceD3D, sourceIndex, &sourceResource, &sourceSubresource)); + + gl::ImageIndex dIndex = gl::ImageIndex::Make2DArray(destLevel, i + destOffset.z); + UINT destSubresource = 0; + ANGLE_TRY(destStorage11->getSubresourceIndex(context, dIndex, &destSubresource)); + + mDeviceContext->CopySubresourceRegion( + destResource->get(), destSubresource, destOffset.x, destOffset.y, 0, + sourceResource->get(), sourceSubresource, &d3dBox); + } + } + else + { + UNREACHABLE(); + } + } + else + { + TextureStorage *sourceStorage = nullptr; + ANGLE_TRY(sourceD3D->getNativeTexture(context, &sourceStorage)); + + TextureStorage11 *sourceStorage11 = GetAs<TextureStorage11>(sourceStorage); + ASSERT(sourceStorage11); + + const d3d11::SharedSRV *sourceSRV = nullptr; + ANGLE_TRY(sourceStorage11->getSRVLevels(context, sourceLevel, sourceLevel, &sourceSRV)); + + gl::ImageIndex destIndex; + if (destTarget == gl::TextureTarget::_2D || destTarget == gl::TextureTarget::_3D || + gl::IsCubeMapFaceTarget(destTarget)) + { + destIndex = gl::ImageIndex::MakeFromTarget(destTarget, destLevel, 1); + } + else if (destTarget == gl::TextureTarget::_2DArray) + { + destIndex = gl::ImageIndex::Make2DArrayRange(destLevel, 0, sourceImageDesc.size.depth); + } + else + { + UNREACHABLE(); + } + + RenderTargetD3D *destRenderTargetD3D = nullptr; + ANGLE_TRY(destStorage11->getRenderTarget( + context, destIndex, destStorage11->getRenderToTextureSamples(), &destRenderTargetD3D)); + + RenderTarget11 *destRenderTarget11 = GetAs<RenderTarget11>(destRenderTargetD3D); + + const d3d11::RenderTargetView &destRTV = destRenderTarget11->getRenderTargetView(); + ASSERT(destRTV.valid()); + + gl::Box sourceArea(sourceBox.x, sourceBox.y, sourceBox.z, sourceBox.width, sourceBox.height, + sourceBox.depth); + + if (unpackFlipY) + { + sourceArea.y += sourceArea.height; + sourceArea.height = -sourceArea.height; + } + + gl::Box destArea(destOffset.x, destOffset.y, destOffset.z, sourceBox.width, + sourceBox.height, sourceBox.depth); + + gl::Extents destSize(destRenderTarget11->getWidth(), destRenderTarget11->getHeight(), + sourceBox.depth); + + // Use nearest filtering because source and destination are the same size for the direct + // copy + GLenum sourceFormat = source->getFormat(srcTarget, sourceLevel).info->format; + ANGLE_TRY(mBlit->copyTexture(context, *sourceSRV, sourceArea, sourceImageDesc.size, + sourceFormat, destRTV, destArea, destSize, nullptr, destFormat, + destType, GL_NEAREST, false, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha)); + } + + destStorage11->markLevelDirty(destLevel); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyCompressedTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + TextureStorage *storage, + GLint destLevel) +{ + TextureStorage11_2D *destStorage11 = GetAs<TextureStorage11_2D>(storage); + ASSERT(destStorage11); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(destStorage11->getResource(context, &destResource)); + + gl::ImageIndex destIndex = gl::ImageIndex::Make2D(destLevel); + UINT destSubresource = 0; + ANGLE_TRY(destStorage11->getSubresourceIndex(context, destIndex, &destSubresource)); + + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + ASSERT(sourceD3D); + + TextureStorage *sourceStorage = nullptr; + ANGLE_TRY(sourceD3D->getNativeTexture(context, &sourceStorage)); + + TextureStorage11_2D *sourceStorage11 = GetAs<TextureStorage11_2D>(sourceStorage); + ASSERT(sourceStorage11); + + const TextureHelper11 *sourceResource = nullptr; + ANGLE_TRY(sourceStorage11->getResource(context, &sourceResource)); + + gl::ImageIndex sourceIndex = gl::ImageIndex::Make2D(sourceLevel); + UINT sourceSubresource = 0; + ANGLE_TRY(sourceStorage11->getSubresourceIndex(context, sourceIndex, &sourceSubresource)); + + mDeviceContext->CopySubresourceRegion(destResource->get(), destSubresource, 0, 0, 0, + sourceResource->get(), sourceSubresource, nullptr); + + return angle::Result::Continue; +} + +angle::Result Renderer11::createRenderTarget(const gl::Context *context, + int width, + int height, + GLenum format, + GLsizei samples, + RenderTargetD3D **outRT) +{ + const d3d11::Format &formatInfo = d3d11::Format::Get(format, mRenderer11DeviceCaps); + + const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format); + GLuint supportedSamples = textureCaps.getNearestSamples(samples); + + Context11 *context11 = GetImplAs<Context11>(context); + + if (width > 0 && height > 0) + { + // Create texture resource + D3D11_TEXTURE2D_DESC desc; + desc.Width = width; + desc.Height = height; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Format = formatInfo.texFormat; + desc.SampleDesc.Count = (supportedSamples == 0) ? 1 : supportedSamples; + desc.SampleDesc.Quality = getSampleDescQuality(supportedSamples); + desc.Usage = D3D11_USAGE_DEFAULT; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + // If a rendertarget or depthstencil format exists for this texture format, + // we'll flag it to allow binding that way. Shader resource views are a little + // more complicated. + bool bindRTV = false, bindDSV = false, bindSRV = false; + bindRTV = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); + bindDSV = (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); + bindSRV = (formatInfo.srvFormat != DXGI_FORMAT_UNKNOWN); + + bool isMultisampledDepthStencil = bindDSV && desc.SampleDesc.Count > 1; + if (isMultisampledDepthStencil && + !mRenderer11DeviceCaps.supportsMultisampledDepthStencilSRVs) + { + bindSRV = false; + } + + desc.BindFlags = (bindRTV ? D3D11_BIND_RENDER_TARGET : 0) | + (bindDSV ? D3D11_BIND_DEPTH_STENCIL : 0) | + (bindSRV ? D3D11_BIND_SHADER_RESOURCE : 0); + + // The format must be either an RTV or a DSV + ASSERT(bindRTV != bindDSV); + + TextureHelper11 texture; + ANGLE_TRY(allocateTexture(context11, desc, formatInfo, &texture)); + texture.setInternalName("createRenderTarget.Texture"); + + d3d11::SharedSRV srv; + d3d11::SharedSRV blitSRV; + if (bindSRV) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = formatInfo.srvFormat; + srvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_SRV_DIMENSION_TEXTURE2D + : D3D11_SRV_DIMENSION_TEXTURE2DMS; + srvDesc.Texture2D.MostDetailedMip = 0; + srvDesc.Texture2D.MipLevels = 1; + + ANGLE_TRY(allocateResource(context11, srvDesc, texture.get(), &srv)); + srv.setInternalName("createRenderTarget.SRV"); + + if (formatInfo.blitSRVFormat != formatInfo.srvFormat) + { + D3D11_SHADER_RESOURCE_VIEW_DESC blitSRVDesc; + blitSRVDesc.Format = formatInfo.blitSRVFormat; + blitSRVDesc.ViewDimension = (supportedSamples == 0) + ? D3D11_SRV_DIMENSION_TEXTURE2D + : D3D11_SRV_DIMENSION_TEXTURE2DMS; + blitSRVDesc.Texture2D.MostDetailedMip = 0; + blitSRVDesc.Texture2D.MipLevels = 1; + + ANGLE_TRY(allocateResource(context11, blitSRVDesc, texture.get(), &blitSRV)); + blitSRV.setInternalName("createRenderTarget.BlitSRV"); + } + else + { + blitSRV = srv.makeCopy(); + } + } + + if (bindDSV) + { + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = formatInfo.dsvFormat; + dsvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_DSV_DIMENSION_TEXTURE2D + : D3D11_DSV_DIMENSION_TEXTURE2DMS; + dsvDesc.Texture2D.MipSlice = 0; + dsvDesc.Flags = 0; + + d3d11::DepthStencilView dsv; + ANGLE_TRY(allocateResource(context11, dsvDesc, texture.get(), &dsv)); + dsv.setInternalName("createRenderTarget.DSV"); + + *outRT = new TextureRenderTarget11(std::move(dsv), texture, srv, format, formatInfo, + width, height, 1, supportedSamples); + } + else if (bindRTV) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = formatInfo.rtvFormat; + rtvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_RTV_DIMENSION_TEXTURE2D + : D3D11_RTV_DIMENSION_TEXTURE2DMS; + rtvDesc.Texture2D.MipSlice = 0; + + d3d11::RenderTargetView rtv; + ANGLE_TRY(allocateResource(context11, rtvDesc, texture.get(), &rtv)); + rtv.setInternalName("createRenderTarget.RTV"); + + if (formatInfo.dataInitializerFunction != nullptr) + { + const float clearValues[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + mDeviceContext->ClearRenderTargetView(rtv.get(), clearValues); + } + + *outRT = new TextureRenderTarget11(std::move(rtv), texture, srv, blitSRV, format, + formatInfo, width, height, 1, supportedSamples); + } + else + { + UNREACHABLE(); + } + } + else + { + *outRT = new TextureRenderTarget11(d3d11::RenderTargetView(), TextureHelper11(), + d3d11::SharedSRV(), d3d11::SharedSRV(), format, + d3d11::Format::Get(GL_NONE, mRenderer11DeviceCaps), + width, height, 1, supportedSamples); + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::createRenderTargetCopy(const gl::Context *context, + RenderTargetD3D *source, + RenderTargetD3D **outRT) +{ + ASSERT(source != nullptr); + + RenderTargetD3D *newRT = nullptr; + ANGLE_TRY(createRenderTarget(context, source->getWidth(), source->getHeight(), + source->getInternalFormat(), source->getSamples(), &newRT)); + + RenderTarget11 *source11 = GetAs<RenderTarget11>(source); + RenderTarget11 *dest11 = GetAs<RenderTarget11>(newRT); + + mDeviceContext->CopySubresourceRegion(dest11->getTexture().get(), dest11->getSubresourceIndex(), + 0, 0, 0, source11->getTexture().get(), + source11->getSubresourceIndex(), nullptr); + *outRT = newRT; + return angle::Result::Continue; +} + +angle::Result Renderer11::loadExecutable(d3d::Context *context, + const uint8_t *function, + size_t length, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + ShaderExecutableD3D **outExecutable) +{ + ShaderData shaderData(function, length); + + switch (type) + { + case gl::ShaderType::Vertex: + { + d3d11::VertexShader vertexShader; + d3d11::GeometryShader streamOutShader; + ANGLE_TRY(allocateResource(context, shaderData, &vertexShader)); + + if (!streamOutVaryings.empty()) + { + std::vector<D3D11_SO_DECLARATION_ENTRY> soDeclaration; + soDeclaration.reserve(streamOutVaryings.size()); + + for (const auto &streamOutVarying : streamOutVaryings) + { + D3D11_SO_DECLARATION_ENTRY entry = {}; + entry.Stream = 0; + entry.SemanticName = streamOutVarying.semanticName.c_str(); + entry.SemanticIndex = streamOutVarying.semanticIndex; + entry.StartComponent = 0; + entry.ComponentCount = static_cast<BYTE>(streamOutVarying.componentCount); + entry.OutputSlot = static_cast<BYTE>( + (separatedOutputBuffers ? streamOutVarying.outputSlot : 0)); + soDeclaration.push_back(entry); + } + + ANGLE_TRY(allocateResource(context, shaderData, &soDeclaration, &streamOutShader)); + } + + *outExecutable = new ShaderExecutable11(function, length, std::move(vertexShader), + std::move(streamOutShader)); + } + break; + case gl::ShaderType::Fragment: + { + d3d11::PixelShader pixelShader; + ANGLE_TRY(allocateResource(context, shaderData, &pixelShader)); + *outExecutable = new ShaderExecutable11(function, length, std::move(pixelShader)); + } + break; + case gl::ShaderType::Geometry: + { + d3d11::GeometryShader geometryShader; + ANGLE_TRY(allocateResource(context, shaderData, &geometryShader)); + *outExecutable = new ShaderExecutable11(function, length, std::move(geometryShader)); + } + break; + case gl::ShaderType::Compute: + { + d3d11::ComputeShader computeShader; + ANGLE_TRY(allocateResource(context, shaderData, &computeShader)); + *outExecutable = new ShaderExecutable11(function, length, std::move(computeShader)); + } + break; + default: + ANGLE_HR_UNREACHABLE(context); + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::compileToExecutable(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &shaderHLSL, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + const CompilerWorkaroundsD3D &workarounds, + ShaderExecutableD3D **outExectuable) +{ + std::stringstream profileStream; + + switch (type) + { + case gl::ShaderType::Vertex: + profileStream << "vs"; + break; + case gl::ShaderType::Fragment: + profileStream << "ps"; + break; + case gl::ShaderType::Geometry: + profileStream << "gs"; + break; + case gl::ShaderType::Compute: + profileStream << "cs"; + break; + default: + ANGLE_HR_UNREACHABLE(context); + } + + profileStream << "_" << getMajorShaderModel() << "_" << getMinorShaderModel() + << getShaderModelSuffix(); + std::string profile = profileStream.str(); + + UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL2; + +#if defined(ANGLE_ENABLE_DEBUG_TRACE) +# ifndef NDEBUG + flags = D3DCOMPILE_SKIP_OPTIMIZATION; +# endif // NDEBUG + flags |= D3DCOMPILE_DEBUG; +#endif // defined(ANGLE_ENABLE_DEBUG_TRACE) + + if (workarounds.enableIEEEStrictness) + flags |= D3DCOMPILE_IEEE_STRICTNESS; + + // Sometimes D3DCompile will fail with the default compilation flags for complicated shaders + // when it would otherwise pass with alternative options. + // Try the default flags first and if compilation fails, try some alternatives. + std::vector<CompileConfig> configs; + configs.push_back(CompileConfig(flags, "default")); + configs.push_back(CompileConfig(flags | D3DCOMPILE_SKIP_VALIDATION, "skip validation")); + configs.push_back(CompileConfig(flags | D3DCOMPILE_SKIP_OPTIMIZATION, "skip optimization")); + + if (getMajorShaderModel() == 4 && getShaderModelSuffix() != "") + { + // Some shaders might cause a "blob content mismatch between level9 and d3d10 shader". + // e.g. dEQP-GLES2.functional.shaders.struct.local.loop_nested_struct_array_*. + // Using the [unroll] directive works around this, as does this D3DCompile flag. + configs.push_back( + CompileConfig(flags | D3DCOMPILE_AVOID_FLOW_CONTROL, "avoid flow control")); + } + + D3D_SHADER_MACRO loopMacros[] = {{"ANGLE_ENABLE_LOOP_FLATTEN", "1"}, {0, 0}}; + + // TODO(jmadill): Use ComPtr? + ID3DBlob *binary = nullptr; + std::string debugInfo; + ANGLE_TRY(mCompiler.compileToBinary(context, infoLog, shaderHLSL, profile, configs, loopMacros, + &binary, &debugInfo)); + + // It's possible that binary is NULL if the compiler failed in all configurations. Set the + // executable to NULL and return GL_NO_ERROR to signify that there was a link error but the + // internal state is still OK. + if (!binary) + { + *outExectuable = nullptr; + return angle::Result::Continue; + } + + angle::Result error = loadExecutable( + context, static_cast<const uint8_t *>(binary->GetBufferPointer()), binary->GetBufferSize(), + type, streamOutVaryings, separatedOutputBuffers, outExectuable); + + SafeRelease(binary); + if (error == angle::Result::Stop) + { + return error; + } + + if (!debugInfo.empty()) + { + (*outExectuable)->appendDebugInfo(debugInfo); + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::ensureHLSLCompilerInitialized(d3d::Context *context) +{ + return mCompiler.ensureInitialized(context); +} + +UniformStorageD3D *Renderer11::createUniformStorage(size_t storageSize) +{ + return new UniformStorage11(storageSize); +} + +VertexBuffer *Renderer11::createVertexBuffer() +{ + return new VertexBuffer11(this); +} + +IndexBuffer *Renderer11::createIndexBuffer() +{ + return new IndexBuffer11(this); +} + +StreamProducerImpl *Renderer11::createStreamProducerD3DTexture( + egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) +{ + return new StreamProducerD3DTexture(this); +} + +bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const +{ + ASSERT(getNativeExtensions().pixelBufferObjectNV); + + const gl::InternalFormat &internalFormatInfo = gl::GetSizedInternalFormatInfo(internalFormat); + const d3d11::Format &d3d11FormatInfo = + d3d11::Format::Get(internalFormat, mRenderer11DeviceCaps); + + // sRGB formats do not work with D3D11 buffer SRVs + if (internalFormatInfo.colorEncoding == GL_SRGB) + { + return false; + } + + // We cannot support direct copies to non-color-renderable formats + if (d3d11FormatInfo.rtvFormat == DXGI_FORMAT_UNKNOWN) + { + return false; + } + + // We skip all 3-channel formats since sometimes format support is missing + if (internalFormatInfo.componentCount == 3) + { + return false; + } + + // We don't support formats which we can't represent without conversion + if (d3d11FormatInfo.format().glInternalFormat != internalFormat) + { + return false; + } + + // Buffer SRV creation for this format was not working on Windows 10. + if (d3d11FormatInfo.texFormat == DXGI_FORMAT_B5G5R5A1_UNORM) + { + return false; + } + + // This format is not supported as a buffer SRV. + if (d3d11FormatInfo.texFormat == DXGI_FORMAT_A8_UNORM) + { + return false; + } + + return true; +} + +angle::Result Renderer11::fastCopyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) +{ + ASSERT(supportsFastCopyBufferToTexture(destinationFormat)); + return mPixelTransfer->copyBufferToTexture(context, unpack, unpackBuffer, offset, + destRenderTarget, destinationFormat, + sourcePixelsType, destArea); +} + +ImageD3D *Renderer11::createImage() +{ + return new Image11(this); +} + +ExternalImageSiblingImpl *Renderer11::createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) +{ + switch (target) + { + case EGL_D3D11_TEXTURE_ANGLE: + return new ExternalImageSiblingImpl11(this, buffer, attribs); + + default: + UNREACHABLE(); + return nullptr; + } +} + +angle::Result Renderer11::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src) +{ + Image11 *dest11 = GetAs<Image11>(dest); + Image11 *src11 = GetAs<Image11>(src); + return Image11::GenerateMipmap(context, dest11, src11, mRenderer11DeviceCaps); +} + +angle::Result Renderer11::generateMipmapUsingD3D(const gl::Context *context, + TextureStorage *storage, + const gl::TextureState &textureState) +{ + TextureStorage11 *storage11 = GetAs<TextureStorage11>(storage); + + ASSERT(storage11->isRenderTarget()); + ASSERT(storage11->supportsNativeMipmapFunction()); + + const d3d11::SharedSRV *srv = nullptr; + ANGLE_TRY(storage11->getSRVLevels(context, textureState.getEffectiveBaseLevel(), + textureState.getEffectiveMaxLevel(), &srv)); + + mDeviceContext->GenerateMips(srv->get()); + + return angle::Result::Continue; +} + +angle::Result Renderer11::copyImage(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + Image11 *dest11 = GetAs<Image11>(dest); + Image11 *src11 = GetAs<Image11>(source); + return Image11::CopyImage(context, dest11, src11, sourceBox, destOffset, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha, mRenderer11DeviceCaps); +} + +TextureStorage *Renderer11::createTextureStorage2D(SwapChainD3D *swapChain, + const std::string &label) +{ + SwapChain11 *swapChain11 = GetAs<SwapChain11>(swapChain); + return new TextureStorage11_2D(this, swapChain11, label); +} + +TextureStorage *Renderer11::createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D, + const std::string &label) +{ + return new TextureStorage11_EGLImage(this, eglImage, GetAs<RenderTarget11>(renderTargetD3D), + label); +} + +TextureStorage *Renderer11::createTextureStorageExternal( + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc, + const std::string &label) +{ + return new TextureStorage11_External(this, stream, desc, label); +} + +TextureStorage *Renderer11::createTextureStorage2D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) +{ + return new TextureStorage11_2D(this, internalformat, bindFlags, width, height, levels, label, + hintLevelZeroOnly); +} + +TextureStorage *Renderer11::createTextureStorageCube(GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) +{ + return new TextureStorage11_Cube(this, internalformat, bindFlags, size, levels, + hintLevelZeroOnly, label); +} + +TextureStorage *Renderer11::createTextureStorage3D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) +{ + return new TextureStorage11_3D(this, internalformat, bindFlags, width, height, depth, levels, + label); +} + +TextureStorage *Renderer11::createTextureStorage2DArray(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) +{ + return new TextureStorage11_2DArray(this, internalformat, bindFlags, width, height, depth, + levels, label); +} + +TextureStorage *Renderer11::createTextureStorage2DMultisample(GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) +{ + return new TextureStorage11_2DMultisample(this, internalformat, width, height, levels, samples, + fixedSampleLocations, label); +} + +TextureStorage *Renderer11::createTextureStorageBuffer( + const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) +{ + return new TextureStorage11_Buffer(this, buffer, internalFormat, label); +} + +TextureStorage *Renderer11::createTextureStorage2DMultisampleArray(GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) +{ + return new TextureStorage11_2DMultisampleArray(this, internalformat, width, height, depth, + levels, samples, fixedSampleLocations, label); +} + +angle::Result Renderer11::readFromAttachment(const gl::Context *context, + const gl::FramebufferAttachment &srcAttachment, + const gl::Rectangle &sourceArea, + GLenum format, + GLenum type, + GLuint outputPitch, + const gl::PixelPackState &pack, + uint8_t *pixelsOut) +{ + ASSERT(sourceArea.width >= 0); + ASSERT(sourceArea.height >= 0); + + const bool invertTexture = UsePresentPathFast(this, &srcAttachment); + + RenderTarget11 *rt11 = nullptr; + ANGLE_TRY(srcAttachment.getRenderTarget(context, 0, &rt11)); + ASSERT(rt11->getTexture().valid()); + + const TextureHelper11 &textureHelper = rt11->getTexture(); + unsigned int sourceSubResource = rt11->getSubresourceIndex(); + + const gl::Extents &texSize = textureHelper.getExtents(); + + gl::Rectangle actualArea = sourceArea; + bool reverseRowOrder = pack.reverseRowOrder; + if (invertTexture) + { + actualArea.y = texSize.height - actualArea.y - actualArea.height; + reverseRowOrder = !reverseRowOrder; + } + + // Clamp read region to the defined texture boundaries, preventing out of bounds reads + // and reads of uninitialized data. + gl::Rectangle safeArea; + safeArea.x = gl::clamp(actualArea.x, 0, texSize.width); + safeArea.y = gl::clamp(actualArea.y, 0, texSize.height); + safeArea.width = + gl::clamp(actualArea.width + std::min(actualArea.x, 0), 0, texSize.width - safeArea.x); + safeArea.height = + gl::clamp(actualArea.height + std::min(actualArea.y, 0), 0, texSize.height - safeArea.y); + + ASSERT(safeArea.x >= 0 && safeArea.y >= 0); + ASSERT(safeArea.x + safeArea.width <= texSize.width); + ASSERT(safeArea.y + safeArea.height <= texSize.height); + + if (safeArea.width == 0 || safeArea.height == 0) + { + // no work to do + return angle::Result::Continue; + } + + gl::Extents safeSize(safeArea.width, safeArea.height, 1); + TextureHelper11 stagingHelper; + ANGLE_TRY(createStagingTexture(context, textureHelper.getTextureType(), + textureHelper.getFormatSet(), safeSize, StagingAccess::READ, + &stagingHelper)); + stagingHelper.setInternalName("readFromAttachment::stagingHelper"); + + TextureHelper11 resolvedTextureHelper; + + // "srcTexture" usually points to the source texture. + // For 2D multisampled textures, it points to the multisampled resolve texture. + const TextureHelper11 *srcTexture = &textureHelper; + + if (textureHelper.is2D() && textureHelper.getSampleCount() > 1) + { + D3D11_TEXTURE2D_DESC resolveDesc; + resolveDesc.Width = static_cast<UINT>(texSize.width); + resolveDesc.Height = static_cast<UINT>(texSize.height); + resolveDesc.MipLevels = 1; + resolveDesc.ArraySize = 1; + resolveDesc.Format = textureHelper.getFormat(); + resolveDesc.SampleDesc.Count = 1; + resolveDesc.SampleDesc.Quality = 0; + resolveDesc.Usage = D3D11_USAGE_DEFAULT; + resolveDesc.BindFlags = 0; + resolveDesc.CPUAccessFlags = 0; + resolveDesc.MiscFlags = 0; + + ANGLE_TRY(allocateTexture(GetImplAs<Context11>(context), resolveDesc, + textureHelper.getFormatSet(), &resolvedTextureHelper)); + resolvedTextureHelper.setInternalName("readFromAttachment::resolvedTextureHelper"); + + mDeviceContext->ResolveSubresource(resolvedTextureHelper.get(), 0, textureHelper.get(), + sourceSubResource, textureHelper.getFormat()); + + sourceSubResource = 0; + srcTexture = &resolvedTextureHelper; + } + + D3D11_BOX srcBox; + srcBox.left = static_cast<UINT>(safeArea.x); + srcBox.right = static_cast<UINT>(safeArea.x + safeArea.width); + srcBox.top = static_cast<UINT>(safeArea.y); + srcBox.bottom = static_cast<UINT>(safeArea.y + safeArea.height); + + // Select the correct layer from a 3D attachment + srcBox.front = 0; + if (textureHelper.is3D()) + { + srcBox.front = static_cast<UINT>(srcAttachment.layer()); + } + srcBox.back = srcBox.front + 1; + + mDeviceContext->CopySubresourceRegion(stagingHelper.get(), 0, 0, 0, 0, srcTexture->get(), + sourceSubResource, &srcBox); + + const angle::Format &angleFormat = GetFormatFromFormatType(format, type); + gl::Buffer *packBuffer = context->getState().getTargetBuffer(gl::BufferBinding::PixelPack); + + PackPixelsParams packParams(safeArea, angleFormat, outputPitch, reverseRowOrder, packBuffer, 0); + return packPixels(context, stagingHelper, packParams, pixelsOut); +} + +angle::Result Renderer11::packPixels(const gl::Context *context, + const TextureHelper11 &textureHelper, + const PackPixelsParams ¶ms, + uint8_t *pixelsOut) +{ + ID3D11Resource *readResource = textureHelper.get(); + + D3D11_MAPPED_SUBRESOURCE mapping; + ANGLE_TRY(mapResource(context, readResource, 0, D3D11_MAP_READ, 0, &mapping)); + + uint8_t *source = static_cast<uint8_t *>(mapping.pData); + int inputPitch = static_cast<int>(mapping.RowPitch); + + const auto &formatInfo = textureHelper.getFormatSet(); + ASSERT(formatInfo.format().glInternalFormat != GL_NONE); + + PackPixels(params, formatInfo.format(), inputPitch, source, pixelsOut); + + mDeviceContext->Unmap(readResource, 0); + + return angle::Result::Continue; +} + +angle::Result Renderer11::blitRenderbufferRect(const gl::Context *context, + const gl::Rectangle &readRectIn, + const gl::Rectangle &drawRectIn, + UINT readLayer, + UINT drawLayer, + RenderTargetD3D *readRenderTarget, + RenderTargetD3D *drawRenderTarget, + GLenum filter, + const gl::Rectangle *scissor, + bool colorBlit, + bool depthBlit, + bool stencilBlit) +{ + // Since blitRenderbufferRect is called for each render buffer that needs to be blitted, + // it should never be the case that both color and depth/stencil need to be blitted at + // at the same time. + ASSERT(colorBlit != (depthBlit || stencilBlit)); + + RenderTarget11 *drawRenderTarget11 = GetAs<RenderTarget11>(drawRenderTarget); + ASSERT(drawRenderTarget11); + + const TextureHelper11 &drawTexture = drawRenderTarget11->getTexture(); + unsigned int drawSubresource = drawRenderTarget11->getSubresourceIndex(); + + RenderTarget11 *readRenderTarget11 = GetAs<RenderTarget11>(readRenderTarget); + ASSERT(readRenderTarget11); + + const gl::Extents readSize(readRenderTarget->getWidth(), readRenderTarget->getHeight(), 1); + const gl::Extents drawSize(drawRenderTarget->getWidth(), drawRenderTarget->getHeight(), 1); + + // From the spec: + // "The actual region taken from the read framebuffer is limited to the intersection of the + // source buffers being transferred, which may include the color buffer selected by the read + // buffer, the depth buffer, and / or the stencil buffer depending on mask." + // This means negative x and y are out of bounds, and not to be read from. We handle this here + // by internally scaling the read and draw rectangles. + + // Remove reversal from readRect to simplify further operations. + gl::Rectangle readRect = readRectIn; + gl::Rectangle drawRect = drawRectIn; + if (readRect.isReversedX()) + { + readRect.x = readRect.x + readRect.width; + readRect.width = -readRect.width; + drawRect.x = drawRect.x + drawRect.width; + drawRect.width = -drawRect.width; + } + if (readRect.isReversedY()) + { + readRect.y = readRect.y + readRect.height; + readRect.height = -readRect.height; + drawRect.y = drawRect.y + drawRect.height; + drawRect.height = -drawRect.height; + } + + gl::Rectangle readBounds(0, 0, readSize.width, readSize.height); + gl::Rectangle inBoundsReadRect; + if (!gl::ClipRectangle(readRect, readBounds, &inBoundsReadRect)) + { + return angle::Result::Continue; + } + + { + // Calculate the drawRect that corresponds to inBoundsReadRect. + auto readToDrawX = [&drawRect, &readRect](int readOffset) { + double readToDrawScale = + static_cast<double>(drawRect.width) / static_cast<double>(readRect.width); + return static_cast<int>( + round(static_cast<double>(readOffset - readRect.x) * readToDrawScale) + drawRect.x); + }; + auto readToDrawY = [&drawRect, &readRect](int readOffset) { + double readToDrawScale = + static_cast<double>(drawRect.height) / static_cast<double>(readRect.height); + return static_cast<int>( + round(static_cast<double>(readOffset - readRect.y) * readToDrawScale) + drawRect.y); + }; + + gl::Rectangle drawRectMatchingInBoundsReadRect; + drawRectMatchingInBoundsReadRect.x = readToDrawX(inBoundsReadRect.x); + drawRectMatchingInBoundsReadRect.y = readToDrawY(inBoundsReadRect.y); + drawRectMatchingInBoundsReadRect.width = + readToDrawX(inBoundsReadRect.x1()) - drawRectMatchingInBoundsReadRect.x; + drawRectMatchingInBoundsReadRect.height = + readToDrawY(inBoundsReadRect.y1()) - drawRectMatchingInBoundsReadRect.y; + drawRect = drawRectMatchingInBoundsReadRect; + readRect = inBoundsReadRect; + } + + bool scissorNeeded = false; + if (scissor) + { + gl::Rectangle scissoredDrawRect; + if (!gl::ClipRectangle(drawRect, *scissor, &scissoredDrawRect)) + { + return angle::Result::Continue; + } + scissorNeeded = scissoredDrawRect != drawRect; + } + + const auto &destFormatInfo = + gl::GetSizedInternalFormatInfo(drawRenderTarget->getInternalFormat()); + const auto &srcFormatInfo = + gl::GetSizedInternalFormatInfo(readRenderTarget->getInternalFormat()); + const auto &formatSet = drawRenderTarget11->getFormatSet(); + const auto &nativeFormat = formatSet.format(); + + // Some blits require masking off emulated texture channels. eg: from RGBA8 to RGB8, we + // emulate RGB8 with RGBA8, so we need to mask off the alpha channel when we copy. + + gl::Color<bool> colorMask; + colorMask.red = + (srcFormatInfo.redBits > 0) && (destFormatInfo.redBits == 0) && (nativeFormat.redBits > 0); + colorMask.green = (srcFormatInfo.greenBits > 0) && (destFormatInfo.greenBits == 0) && + (nativeFormat.greenBits > 0); + colorMask.blue = (srcFormatInfo.blueBits > 0) && (destFormatInfo.blueBits == 0) && + (nativeFormat.blueBits > 0); + colorMask.alpha = (srcFormatInfo.alphaBits > 0) && (destFormatInfo.alphaBits == 0) && + (nativeFormat.alphaBits > 0); + + // We only currently support masking off the alpha channel. + bool colorMaskingNeeded = colorMask.alpha; + ASSERT(!colorMask.red && !colorMask.green && !colorMask.blue); + + bool wholeBufferCopy = !scissorNeeded && !colorMaskingNeeded && readRect.x == 0 && + readRect.width == readSize.width && readRect.y == 0 && + readRect.height == readSize.height && drawRect.x == 0 && + drawRect.width == drawSize.width && drawRect.y == 0 && + drawRect.height == drawSize.height; + + bool stretchRequired = readRect.width != drawRect.width || readRect.height != drawRect.height; + + ASSERT(!readRect.isReversedX() && !readRect.isReversedY()); + bool reversalRequired = drawRect.isReversedX() || drawRect.isReversedY(); + + bool outOfBounds = readRect.x < 0 || readRect.x + readRect.width > readSize.width || + readRect.y < 0 || readRect.y + readRect.height > readSize.height || + drawRect.x < 0 || drawRect.x + drawRect.width > drawSize.width || + drawRect.y < 0 || drawRect.y + drawRect.height > drawSize.height; + + bool partialDSBlit = + (nativeFormat.depthBits > 0 && depthBlit) != (nativeFormat.stencilBits > 0 && stencilBlit); + + const bool canCopySubresource = + drawRenderTarget->getSamples() == readRenderTarget->getSamples() && + readRenderTarget11->getFormatSet().formatID == + drawRenderTarget11->getFormatSet().formatID && + !stretchRequired && !outOfBounds && !reversalRequired && !partialDSBlit && + !colorMaskingNeeded && (!(depthBlit || stencilBlit) || wholeBufferCopy); + + TextureHelper11 readTexture; + unsigned int readSubresource = 0; + d3d11::SharedSRV readSRV; + + if (readRenderTarget->isMultisampled()) + { + ANGLE_TRY(resolveMultisampledTexture(context, readRenderTarget11, depthBlit, stencilBlit, + &readTexture)); + + if (!stencilBlit && !canCopySubresource) + { + const auto &readFormatSet = readTexture.getFormatSet(); + + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = readFormatSet.srvFormat; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + viewDesc.Texture2D.MipLevels = 1; + viewDesc.Texture2D.MostDetailedMip = 0; + + ANGLE_TRY(allocateResource(GetImplAs<Context11>(context), viewDesc, readTexture.get(), + &readSRV)); + } + } + else + { + ASSERT(readRenderTarget11); + readTexture = readRenderTarget11->getTexture(); + readSubresource = readRenderTarget11->getSubresourceIndex(); + if (!canCopySubresource) + { + const d3d11::SharedSRV *blitSRV; + ANGLE_TRY(readRenderTarget11->getBlitShaderResourceView(context, &blitSRV)); + readSRV = blitSRV->makeCopy(); + if (!readSRV.valid()) + { + ASSERT(depthBlit || stencilBlit); + const d3d11::SharedSRV *srv; + ANGLE_TRY(readRenderTarget11->getShaderResourceView(context, &srv)); + readSRV = srv->makeCopy(); + } + ASSERT(readSRV.valid()); + } + } + + if (canCopySubresource) + { + UINT dstX = drawRect.x; + UINT dstY = drawRect.y; + UINT dstZ = drawLayer; + + D3D11_BOX readBox; + readBox.left = readRect.x; + readBox.right = readRect.x + readRect.width; + readBox.top = readRect.y; + readBox.bottom = readRect.y + readRect.height; + readBox.front = readLayer; + readBox.back = readLayer + 1; + + if (scissorNeeded) + { + // drawRect is guaranteed to have positive width and height because stretchRequired is + // false. + ASSERT(drawRect.width >= 0 || drawRect.height >= 0); + + if (drawRect.x < scissor->x) + { + dstX = scissor->x; + readBox.left += (scissor->x - drawRect.x); + } + if (drawRect.y < scissor->y) + { + dstY = scissor->y; + readBox.top += (scissor->y - drawRect.y); + } + if (drawRect.x + drawRect.width > scissor->x + scissor->width) + { + readBox.right -= ((drawRect.x + drawRect.width) - (scissor->x + scissor->width)); + } + if (drawRect.y + drawRect.height > scissor->y + scissor->height) + { + readBox.bottom -= ((drawRect.y + drawRect.height) - (scissor->y + scissor->height)); + } + } + + // D3D11 needs depth-stencil CopySubresourceRegions to have a NULL pSrcBox + // We also require complete framebuffer copies for depth-stencil blit. + D3D11_BOX *pSrcBox = wholeBufferCopy && readLayer == 0 ? nullptr : &readBox; + + mDeviceContext->CopySubresourceRegion(drawTexture.get(), drawSubresource, dstX, dstY, dstZ, + readTexture.get(), readSubresource, pSrcBox); + } + else + { + gl::Box readArea(readRect.x, readRect.y, 0, readRect.width, readRect.height, 1); + gl::Box drawArea(drawRect.x, drawRect.y, 0, drawRect.width, drawRect.height, 1); + + if (depthBlit && stencilBlit) + { + ANGLE_TRY(mBlit->copyDepthStencil(context, readTexture, readSubresource, readArea, + readSize, drawTexture, drawSubresource, drawArea, + drawSize, scissor)); + } + else if (depthBlit) + { + const d3d11::DepthStencilView &drawDSV = drawRenderTarget11->getDepthStencilView(); + ASSERT(readSRV.valid()); + ANGLE_TRY(mBlit->copyDepth(context, readSRV, readArea, readSize, drawDSV, drawArea, + drawSize, scissor)); + } + else if (stencilBlit) + { + ANGLE_TRY(mBlit->copyStencil(context, readTexture, readSubresource, readArea, readSize, + drawTexture, drawSubresource, drawArea, drawSize, + scissor)); + } + else + { + const d3d11::RenderTargetView &drawRTV = drawRenderTarget11->getRenderTargetView(); + + // We don't currently support masking off any other channel than alpha + bool maskOffAlpha = colorMaskingNeeded && colorMask.alpha; + ASSERT(readSRV.valid()); + ANGLE_TRY(mBlit->copyTexture(context, readSRV, readArea, readSize, srcFormatInfo.format, + drawRTV, drawArea, drawSize, scissor, + destFormatInfo.format, GL_NONE, filter, maskOffAlpha, + false, false)); + } + } + + return angle::Result::Continue; +} + +bool Renderer11::isES3Capable() const +{ + return (d3d11_gl::GetMaximumClientVersion(mRenderer11DeviceCaps).major > 2); +} + +RendererClass Renderer11::getRendererClass() const +{ + return RENDERER_D3D11; +} + +void Renderer11::onSwap() +{ + // Send histogram updates every half hour + const double kHistogramUpdateInterval = 30 * 60; + + auto *platform = ANGLEPlatformCurrent(); + const double currentTime = platform->monotonicallyIncreasingTime(platform); + const double timeSinceLastUpdate = currentTime - mLastHistogramUpdateTime; + + if (timeSinceLastUpdate > kHistogramUpdateInterval) + { + updateHistograms(); + mLastHistogramUpdateTime = currentTime; + } +} + +void Renderer11::updateHistograms() +{ + // Update the buffer CPU memory histogram + { + size_t sizeSum = 0; + for (const Buffer11 *buffer : mAliveBuffers) + { + sizeSum += buffer->getTotalCPUBufferMemoryBytes(); + } + const int kOneMegaByte = 1024 * 1024; + ANGLE_HISTOGRAM_MEMORY_MB("GPU.ANGLE.Buffer11CPUMemoryMB", + static_cast<int>(sizeSum) / kOneMegaByte); + } +} + +void Renderer11::onBufferCreate(const Buffer11 *created) +{ + mAliveBuffers.insert(created); +} + +void Renderer11::onBufferDelete(const Buffer11 *deleted) +{ + mAliveBuffers.erase(deleted); +} + +angle::Result Renderer11::resolveMultisampledTexture(const gl::Context *context, + RenderTarget11 *renderTarget, + bool depth, + bool stencil, + TextureHelper11 *textureOut) +{ + if (depth && !stencil) + { + return mBlit->resolveDepth(context, renderTarget, textureOut); + } + + if (stencil) + { + return mBlit->resolveStencil(context, renderTarget, depth, textureOut); + } + + const auto &formatSet = renderTarget->getFormatSet(); + + ASSERT(renderTarget->isMultisampled()); + const d3d11::SharedSRV *sourceSRV; + ANGLE_TRY(renderTarget->getShaderResourceView(context, &sourceSRV)); + D3D11_SHADER_RESOURCE_VIEW_DESC sourceSRVDesc; + sourceSRV->get()->GetDesc(&sourceSRVDesc); + ASSERT(sourceSRVDesc.ViewDimension == D3D_SRV_DIMENSION_TEXTURE2DMS || + sourceSRVDesc.ViewDimension == D3D_SRV_DIMENSION_TEXTURE2DMSARRAY); + + if (!mCachedResolveTexture.valid() || + mCachedResolveTexture.getExtents().width != renderTarget->getWidth() || + mCachedResolveTexture.getExtents().height != renderTarget->getHeight() || + mCachedResolveTexture.getFormat() != formatSet.texFormat) + { + D3D11_TEXTURE2D_DESC resolveDesc; + resolveDesc.Width = renderTarget->getWidth(); + resolveDesc.Height = renderTarget->getHeight(); + resolveDesc.MipLevels = 1; + resolveDesc.ArraySize = 1; + resolveDesc.Format = formatSet.texFormat; + resolveDesc.SampleDesc.Count = 1; + resolveDesc.SampleDesc.Quality = 0; + resolveDesc.Usage = D3D11_USAGE_DEFAULT; + resolveDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + resolveDesc.CPUAccessFlags = 0; + resolveDesc.MiscFlags = 0; + + ANGLE_TRY(allocateTexture(GetImplAs<Context11>(context), resolveDesc, formatSet, + &mCachedResolveTexture)); + } + + mDeviceContext->ResolveSubresource(mCachedResolveTexture.get(), 0, + renderTarget->getTexture().get(), + renderTarget->getSubresourceIndex(), formatSet.texFormat); + *textureOut = mCachedResolveTexture; + return angle::Result::Continue; +} + +bool Renderer11::getLUID(LUID *adapterLuid) const +{ + adapterLuid->HighPart = 0; + adapterLuid->LowPart = 0; + + if (!mDxgiAdapter) + { + return false; + } + + DXGI_ADAPTER_DESC adapterDesc; + if (FAILED(mDxgiAdapter->GetDesc(&adapterDesc))) + { + return false; + } + + *adapterLuid = adapterDesc.AdapterLuid; + return true; +} + +VertexConversionType Renderer11::getVertexConversionType(angle::FormatID vertexFormatID) const +{ + return d3d11::GetVertexFormatInfo(vertexFormatID, mRenderer11DeviceCaps.featureLevel) + .conversionType; +} + +GLenum Renderer11::getVertexComponentType(angle::FormatID vertexFormatID) const +{ + const auto &format = + d3d11::GetVertexFormatInfo(vertexFormatID, mRenderer11DeviceCaps.featureLevel); + return d3d11::GetComponentType(format.nativeFormat); +} + +angle::Result Renderer11::getVertexSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *bytesRequiredOut) const +{ + if (!attrib.enabled) + { + *bytesRequiredOut = 16u; + return angle::Result::Continue; + } + + unsigned int elementCount = 0; + const unsigned int divisor = binding.getDivisor(); + if (instances == 0 || divisor == 0) + { + // This could be a clipped cast. + elementCount = gl::clampCast<unsigned int>(count); + } + else + { + // Round up to divisor, if possible + elementCount = + UnsignedCeilDivide(static_cast<unsigned int>(instances + baseInstance), divisor); + } + + ASSERT(elementCount > 0); + + const D3D_FEATURE_LEVEL featureLevel = mRenderer11DeviceCaps.featureLevel; + const d3d11::VertexFormat &vertexFormatInfo = + d3d11::GetVertexFormatInfo(attrib.format->id, featureLevel); + const d3d11::DXGIFormatSize &dxgiFormatInfo = + d3d11::GetDXGIFormatSizeInfo(vertexFormatInfo.nativeFormat); + unsigned int elementSize = dxgiFormatInfo.pixelBytes; + bool check = (elementSize > std::numeric_limits<unsigned int>::max() / elementCount); + ANGLE_CHECK(GetImplAs<Context11>(context), !check, + "New vertex buffer size would result in an overflow.", GL_OUT_OF_MEMORY); + + *bytesRequiredOut = elementSize * elementCount; + return angle::Result::Continue; +} + +void Renderer11::generateCaps(gl::Caps *outCaps, + gl::TextureCapsMap *outTextureCaps, + gl::Extensions *outExtensions, + gl::Limitations *outLimitations) const +{ + d3d11_gl::GenerateCaps(mDevice, mDeviceContext, mRenderer11DeviceCaps, getFeatures(), + mDescription, outCaps, outTextureCaps, outExtensions, outLimitations); +} + +void Renderer11::initializeFeatures(angle::FeaturesD3D *features) const +{ + if (!mDisplay->getState().featuresAllDisabled) + { + d3d11::InitializeFeatures(mRenderer11DeviceCaps, mAdapterDescription, features); + } + ApplyFeatureOverrides(features, mDisplay->getState()); +} + +void Renderer11::initializeFrontendFeatures(angle::FrontendFeatures *features) const +{ + if (!mDisplay->getState().featuresAllDisabled) + { + d3d11::InitializeFrontendFeatures(mAdapterDescription, features); + } + ApplyFeatureOverrides(features, mDisplay->getState()); +} + +DeviceImpl *Renderer11::createEGLDevice() +{ + return new DeviceD3D(EGL_D3D11_DEVICE_ANGLE, mDevice); +} + +ContextImpl *Renderer11::createContext(const gl::State &state, gl::ErrorSet *errorSet) +{ + return new Context11(state, errorSet, this); +} + +FramebufferImpl *Renderer11::createDefaultFramebuffer(const gl::FramebufferState &state) +{ + return new Framebuffer11(state, this); +} + +angle::Result Renderer11::getScratchMemoryBuffer(Context11 *context11, + size_t requestedSize, + angle::MemoryBuffer **bufferOut) +{ + ANGLE_CHECK_GL_ALLOC(context11, mScratchMemoryBuffer.get(requestedSize, bufferOut)); + return angle::Result::Continue; +} + +gl::Version Renderer11::getMaxSupportedESVersion() const +{ + return d3d11_gl::GetMaximumClientVersion(mRenderer11DeviceCaps); +} + +gl::Version Renderer11::getMaxConformantESVersion() const +{ + // 3.1 support is in progress. + return std::min(getMaxSupportedESVersion(), gl::Version(3, 0)); +} + +DebugAnnotatorContext11 *Renderer11::getDebugAnnotatorContext() +{ + return &mAnnotatorContext; +} + +angle::Result Renderer11::dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) +{ + const gl::State &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + if (program->getActiveShaderStorageBlockCount() > 0 || + program->getActiveAtomicCounterBufferCount() > 0) + { + ANGLE_TRY(markRawBufferUsage(context)); + } + ANGLE_TRY(markTypedBufferUsage(context)); + ANGLE_TRY(mStateManager.updateStateForCompute(context, numGroupsX, numGroupsY, numGroupsZ)); + mDeviceContext->Dispatch(numGroupsX, numGroupsY, numGroupsZ); + + return angle::Result::Continue; +} +angle::Result Renderer11::dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) +{ + const auto &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + if (program->getActiveShaderStorageBlockCount() > 0 || + program->getActiveAtomicCounterBufferCount() > 0) + { + ANGLE_TRY(markRawBufferUsage(context)); + } + + auto *dispatchIndirectBuffer = glState.getTargetBuffer(gl::BufferBinding::DispatchIndirect); + ASSERT(dispatchIndirectBuffer); + + Buffer11 *storage = GetImplAs<Buffer11>(dispatchIndirectBuffer); + const uint8_t *bufferData = nullptr; + // TODO(jie.a.chen@intel.com): num_groups_x,y,z have to be written into the driver constant + // buffer for the built-in variable gl_NumWorkGroups. There is an opportunity for optimization + // to use GPU->GPU copy instead. + // http://anglebug.com/2807 + ANGLE_TRY(storage->getData(context, &bufferData)); + const GLuint *groups = reinterpret_cast<const GLuint *>(bufferData + indirect); + ANGLE_TRY(mStateManager.updateStateForCompute(context, groups[0], groups[1], groups[2])); + + ID3D11Buffer *buffer = nullptr; + ANGLE_TRY(storage->getBuffer(context, BUFFER_USAGE_INDIRECT, &buffer)); + + mDeviceContext->DispatchIndirect(buffer, static_cast<UINT>(indirect)); + return angle::Result::Continue; +} + +angle::Result Renderer11::createStagingTexture(const gl::Context *context, + ResourceType textureType, + const d3d11::Format &formatSet, + const gl::Extents &size, + StagingAccess readAndWriteAccess, + TextureHelper11 *textureOut) +{ + Context11 *context11 = GetImplAs<Context11>(context); + + if (textureType == ResourceType::Texture2D) + { + D3D11_TEXTURE2D_DESC stagingDesc; + stagingDesc.Width = size.width; + stagingDesc.Height = size.height; + stagingDesc.MipLevels = 1; + stagingDesc.ArraySize = 1; + stagingDesc.Format = formatSet.texFormat; + stagingDesc.SampleDesc.Count = 1; + stagingDesc.SampleDesc.Quality = 0; + stagingDesc.Usage = D3D11_USAGE_STAGING; + stagingDesc.BindFlags = 0; + stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + stagingDesc.MiscFlags = 0; + + if (readAndWriteAccess == StagingAccess::READ_WRITE) + { + stagingDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE; + } + + ANGLE_TRY(allocateTexture(context11, stagingDesc, formatSet, textureOut)); + return angle::Result::Continue; + } + ASSERT(textureType == ResourceType::Texture3D); + + D3D11_TEXTURE3D_DESC stagingDesc; + stagingDesc.Width = size.width; + stagingDesc.Height = size.height; + stagingDesc.Depth = 1; + stagingDesc.MipLevels = 1; + stagingDesc.Format = formatSet.texFormat; + stagingDesc.Usage = D3D11_USAGE_STAGING; + stagingDesc.BindFlags = 0; + stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + stagingDesc.MiscFlags = 0; + + ANGLE_TRY(allocateTexture(context11, stagingDesc, formatSet, textureOut)); + return angle::Result::Continue; +} + +angle::Result Renderer11::allocateTexture(d3d::Context *context, + const D3D11_TEXTURE2D_DESC &desc, + const d3d11::Format &format, + const D3D11_SUBRESOURCE_DATA *initData, + TextureHelper11 *textureOut) +{ + d3d11::Texture2D texture; + ANGLE_TRY(mResourceManager11.allocate(context, this, &desc, initData, &texture)); + textureOut->init(std::move(texture), desc, format); + return angle::Result::Continue; +} + +angle::Result Renderer11::allocateTexture(d3d::Context *context, + const D3D11_TEXTURE3D_DESC &desc, + const d3d11::Format &format, + const D3D11_SUBRESOURCE_DATA *initData, + TextureHelper11 *textureOut) +{ + d3d11::Texture3D texture; + ANGLE_TRY(mResourceManager11.allocate(context, this, &desc, initData, &texture)); + textureOut->init(std::move(texture), desc, format); + return angle::Result::Continue; +} + +angle::Result Renderer11::getBlendState(const gl::Context *context, + const d3d11::BlendStateKey &key, + const d3d11::BlendState **outBlendState) +{ + return mStateCache.getBlendState(context, this, key, outBlendState); +} + +angle::Result Renderer11::getRasterizerState(const gl::Context *context, + const gl::RasterizerState &rasterState, + bool scissorEnabled, + ID3D11RasterizerState **outRasterizerState) +{ + return mStateCache.getRasterizerState(context, this, rasterState, scissorEnabled, + outRasterizerState); +} + +angle::Result Renderer11::getDepthStencilState(const gl::Context *context, + const gl::DepthStencilState &dsState, + const d3d11::DepthStencilState **outDSState) +{ + return mStateCache.getDepthStencilState(context, this, dsState, outDSState); +} + +angle::Result Renderer11::getSamplerState(const gl::Context *context, + const gl::SamplerState &samplerState, + ID3D11SamplerState **outSamplerState) +{ + return mStateCache.getSamplerState(context, this, samplerState, outSamplerState); +} + +UINT Renderer11::getSampleDescQuality(GLuint supportedSamples) const +{ + // Per the documentation on + // https://docs.microsoft.com/en-us/windows/win32/api/d3d11/ne-d3d11-d3d11_standard_multisample_quality_levels + // applications can only request the standard multisample pattern on + // feature levels 10_1 and above. + if (supportedSamples > 0 && mDevice->GetFeatureLevel() >= D3D_FEATURE_LEVEL_10_1) + { + return D3D11_STANDARD_MULTISAMPLE_PATTERN; + } + return 0; +} + +angle::Result Renderer11::clearRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget, + const gl::ColorF &clearColorValue, + const float clearDepthValue, + const unsigned int clearStencilValue) +{ + RenderTarget11 *rt11 = GetAs<RenderTarget11>(renderTarget); + + if (rt11->getFormatSet().dsvFormat != DXGI_FORMAT_UNKNOWN) + { + ASSERT(rt11->getDepthStencilView().valid()); + + const auto &format = rt11->getFormatSet(); + const UINT clearFlags = (format.format().depthBits > 0 ? D3D11_CLEAR_DEPTH : 0) | + (format.format().stencilBits ? D3D11_CLEAR_STENCIL : 0); + mDeviceContext->ClearDepthStencilView(rt11->getDepthStencilView().get(), clearFlags, + clearDepthValue, + static_cast<UINT8>(clearStencilValue)); + return angle::Result::Continue; + } + + ASSERT(rt11->getRenderTargetView().valid()); + ID3D11RenderTargetView *rtv = rt11->getRenderTargetView().get(); + + // There are complications with some types of RTV and FL 9_3 with ClearRenderTargetView. + // See https://msdn.microsoft.com/en-us/library/windows/desktop/ff476388(v=vs.85).aspx + ASSERT(mRenderer11DeviceCaps.featureLevel > D3D_FEATURE_LEVEL_9_3 || !IsArrayRTV(rtv)); + + const auto &d3d11Format = rt11->getFormatSet(); + const auto &glFormat = gl::GetSizedInternalFormatInfo(renderTarget->getInternalFormat()); + + gl::ColorF safeClearColor = clearColorValue; + + if (d3d11Format.format().alphaBits > 0 && glFormat.alphaBits == 0) + { + safeClearColor.alpha = 1.0f; + } + + mDeviceContext->ClearRenderTargetView(rtv, &safeClearColor.red); + return angle::Result::Continue; +} + +bool Renderer11::canSelectViewInVertexShader() const +{ + return !getFeatures().selectViewInGeometryShader.enabled && + getRenderer11DeviceCaps().supportsVpRtIndexWriteFromVertexShader; +} + +angle::Result Renderer11::mapResource(const gl::Context *context, + ID3D11Resource *resource, + UINT subResource, + D3D11_MAP mapType, + UINT mapFlags, + D3D11_MAPPED_SUBRESOURCE *mappedResource) +{ + HRESULT hr = mDeviceContext->Map(resource, subResource, mapType, mapFlags, mappedResource); + ANGLE_TRY_HR(GetImplAs<Context11>(context), hr, "Failed to map D3D11 resource."); + return angle::Result::Continue; +} + +angle::Result Renderer11::markTypedBufferUsage(const gl::Context *context) +{ + const gl::State &glState = context->getState(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram()); + gl::RangeUI imageRange = programD3D->getUsedImageRange(gl::ShaderType::Compute, false); + for (unsigned int imageIndex = imageRange.low(); imageIndex < imageRange.high(); imageIndex++) + { + GLint imageUnitIndex = programD3D->getImageMapping(gl::ShaderType::Compute, imageIndex, + false, context->getCaps()); + ASSERT(imageUnitIndex != -1); + const gl::ImageUnit &imageUnit = glState.getImageUnit(imageUnitIndex); + if (imageUnit.texture.get()->getType() == gl::TextureType::Buffer) + { + Buffer11 *buffer11 = GetImplAs<Buffer11>(imageUnit.texture.get()->getBuffer().get()); + ANGLE_TRY(buffer11->markTypedBufferUsage(context)); + } + } + return angle::Result::Continue; +} + +angle::Result Renderer11::markRawBufferUsage(const gl::Context *context) +{ + const gl::State &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + for (size_t blockIndex = 0; blockIndex < program->getActiveShaderStorageBlockCount(); + blockIndex++) + { + GLuint binding = program->getShaderStorageBlockBinding(static_cast<GLuint>(blockIndex)); + const auto &shaderStorageBuffer = glState.getIndexedShaderStorageBuffer(binding); + if (shaderStorageBuffer.get() != nullptr) + { + Buffer11 *bufferStorage = GetImplAs<Buffer11>(shaderStorageBuffer.get()); + ANGLE_TRY(bufferStorage->markRawBufferUsage(context)); + } + } + + for (const auto &atomicCounterBuffer : program->getState().getAtomicCounterBuffers()) + { + GLuint binding = atomicCounterBuffer.binding; + const auto &buffer = glState.getIndexedAtomicCounterBuffer(binding); + + if (buffer.get() != nullptr) + { + Buffer11 *bufferStorage = GetImplAs<Buffer11>(buffer.get()); + ANGLE_TRY(bufferStorage->markRawBufferUsage(context)); + } + } + return angle::Result::Continue; +} + +angle::Result Renderer11::markTransformFeedbackUsage(const gl::Context *context) +{ + const gl::State &glState = context->getState(); + const gl::TransformFeedback *transformFeedback = glState.getCurrentTransformFeedback(); + for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++) + { + const gl::OffsetBindingPointer<gl::Buffer> &binding = + transformFeedback->getIndexedBuffer(i); + if (binding.get() != nullptr) + { + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get()); + ANGLE_TRY(bufferD3D->markTransformFeedbackUsage(context)); + } + } + + return angle::Result::Continue; +} + +angle::Result Renderer11::getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) +{ + return GetImplAs<Context11>(context)->getIncompleteTexture(context, type, textureOut); +} + +std::string Renderer11::getVendorString() const +{ + return GetVendorString(mAdapterDescription.VendorId); +} + +std::string Renderer11::getVersionString(bool includeFullVersion) const +{ + std::ostringstream versionString; + versionString << "D3D11"; + if (includeFullVersion && mRenderer11DeviceCaps.driverVersion.valid()) + { + versionString << "-" << GetDriverVersionString(mRenderer11DeviceCaps.driverVersion.value()); + } + return versionString.str(); +} + +RendererD3D *CreateRenderer11(egl::Display *display) +{ + return new Renderer11(display); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.h new file mode 100644 index 0000000000..6d4cb214af --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Renderer11.h @@ -0,0 +1,632 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Renderer11.h: Defines a back-end specific class for the D3D11 renderer. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_ + +#include "common/angleutils.h" +#include "common/mathutil.h" +#include "libANGLE/AttributeMap.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/HLSLCompiler.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" +#include "libANGLE/renderer/d3d/d3d11/StateManager11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace gl +{ +class FramebufferAttachment; +class ImageIndex; +} // namespace gl + +namespace rx +{ +class Blit11; +class Buffer11; +class Clear11; +class Context11; +class IndexDataManager; +struct PackPixelsParams; +class PixelTransfer11; +class RenderTarget11; +class StreamingIndexBufferInterface; +class Trim11; +class VertexDataManager; + +struct Renderer11DeviceCaps +{ + Renderer11DeviceCaps(); + + D3D_FEATURE_LEVEL featureLevel; + bool supportsDXGI1_2; // Support for DXGI 1.2 + bool supportsClearView; // Support for ID3D11DeviceContext1::ClearView + bool supportsConstantBufferOffsets; // Support for Constant buffer offset + bool supportsVpRtIndexWriteFromVertexShader; // VP/RT can be selected in the Vertex Shader + // stage. + bool supportsMultisampledDepthStencilSRVs; // D3D feature level 10.0 no longer allows creation + // of textures with both the bind SRV and DSV flags + // when multisampled. Textures will need to be + // resolved before reading. crbug.com/656989 + bool supportsTypedUAVLoadAdditionalFormats; // + bool supportsRasterizerOrderViews; + bool allowES3OnFL10_0; + UINT B5G6R5support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G6R5_UNORM + UINT B5G6R5maxSamples; // Maximum number of samples supported by DXGI_FORMAT_B5G6R5_UNORM + UINT B4G4R4A4support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B4G4R4A4_UNORM + UINT B4G4R4A4maxSamples; // Maximum number of samples supported by DXGI_FORMAT_B4G4R4A4_UNORM + UINT B5G5R5A1support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G5R5A1_UNORM + UINT B5G5R5A1maxSamples; // Maximum number of samples supported by DXGI_FORMAT_B5G5R5A1_UNORM + Optional<LARGE_INTEGER> driverVersion; // Four-part driver version number. +}; + +enum +{ + MAX_VERTEX_UNIFORM_VECTORS_D3D11 = 1024, + MAX_FRAGMENT_UNIFORM_VECTORS_D3D11 = 1024 +}; + +class Renderer11 : public RendererD3D +{ + public: + explicit Renderer11(egl::Display *display); + ~Renderer11() override; + + egl::Error initialize() override; + bool resetDevice() override; + + egl::ConfigSet generateConfigs() override; + void generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const override; + + ContextImpl *createContext(const gl::State &state, gl::ErrorSet *errorSet) override; + + angle::Result flush(Context11 *context11); + angle::Result finish(Context11 *context11); + + bool isValidNativeWindow(EGLNativeWindowType window) const override; + NativeWindowD3D *createNativeWindow(EGLNativeWindowType window, + const egl::Config *config, + const egl::AttributeMap &attribs) const override; + + SwapChainD3D *createSwapChain(NativeWindowD3D *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) override; + egl::Error getD3DTextureInfo(const egl::Config *configuration, + IUnknown *d3dTexture, + const egl::AttributeMap &attribs, + EGLint *width, + EGLint *height, + GLsizei *samples, + gl::Format *glFormat, + const angle::Format **angleFormat, + UINT *arraySlice) const override; + egl::Error validateShareHandle(const egl::Config *config, + HANDLE shareHandle, + const egl::AttributeMap &attribs) const override; + + // lost device + bool testDeviceLost() override; + bool testDeviceResettable() override; + + DeviceIdentifier getAdapterIdentifier() const override; + + unsigned int getReservedVertexUniformVectors() const; + unsigned int getReservedFragmentUniformVectors() const; + gl::ShaderMap<unsigned int> getReservedShaderUniformBuffers() const; + + bool getShareHandleSupport() const; + + int getMajorShaderModel() const override; + int getMinorShaderModel() const override; + std::string getShaderModelSuffix() const override; + + // Pixel operations + angle::Result copyImage2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + angle::Result copyImageCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) override; + angle::Result copyImage3D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + angle::Result copyImage2DArray(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + gl::TextureTarget srcTarget, + const gl::Box &sourceBox, + GLenum destFormat, + GLenum destType, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) override; + angle::Result copyCompressedTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + TextureStorage *storage, + GLint destLevel) override; + + // RenderTarget creation + angle::Result createRenderTarget(const gl::Context *context, + int width, + int height, + GLenum format, + GLsizei samples, + RenderTargetD3D **outRT) override; + angle::Result createRenderTargetCopy(const gl::Context *context, + RenderTargetD3D *source, + RenderTargetD3D **outRT) override; + + // Shader operations + angle::Result loadExecutable(d3d::Context *context, + const uint8_t *function, + size_t length, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + ShaderExecutableD3D **outExecutable) override; + angle::Result compileToExecutable(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &shaderHLSL, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + const CompilerWorkaroundsD3D &workarounds, + ShaderExecutableD3D **outExectuable) override; + angle::Result ensureHLSLCompilerInitialized(d3d::Context *context) override; + + UniformStorageD3D *createUniformStorage(size_t storageSize) override; + + // Image operations + ImageD3D *createImage() override; + ExternalImageSiblingImpl *createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) override; + angle::Result generateMipmap(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source) override; + angle::Result generateMipmapUsingD3D(const gl::Context *context, + TextureStorage *storage, + const gl::TextureState &textureState) override; + angle::Result copyImage(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) override; + + TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain, + const std::string &label) override; + TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D, + const std::string &label) override; + TextureStorage *createTextureStorageExternal(egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc, + const std::string &label) override; + TextureStorage *createTextureStorage2D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) override; + TextureStorage *createTextureStorageCube(GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) override; + TextureStorage *createTextureStorage3D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) override; + TextureStorage *createTextureStorage2DArray(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) override; + TextureStorage *createTextureStorage2DMultisample(GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) override; + + TextureStorage *createTextureStorageBuffer(const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) override; + TextureStorage *createTextureStorage2DMultisampleArray(GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) override; + + VertexBuffer *createVertexBuffer() override; + IndexBuffer *createIndexBuffer() override; + + // Stream Creation + StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) override; + + // D3D11-renderer specific methods + ID3D11Device *getDevice() { return mDevice; } + ID3D11Device1 *getDevice1() { return mDevice1; } + void *getD3DDevice() override; + ID3D11DeviceContext *getDeviceContext() { return mDeviceContext; } + ID3D11DeviceContext1 *getDeviceContext1IfSupported() { return mDeviceContext1; } + IDXGIFactory *getDxgiFactory() { return mDxgiFactory; } + + angle::Result getBlendState(const gl::Context *context, + const d3d11::BlendStateKey &key, + const d3d11::BlendState **outBlendState); + angle::Result getRasterizerState(const gl::Context *context, + const gl::RasterizerState &rasterState, + bool scissorEnabled, + ID3D11RasterizerState **outRasterizerState); + angle::Result getDepthStencilState(const gl::Context *context, + const gl::DepthStencilState &dsState, + const d3d11::DepthStencilState **outDSState); + angle::Result getSamplerState(const gl::Context *context, + const gl::SamplerState &samplerState, + ID3D11SamplerState **outSamplerState); + UINT getSampleDescQuality(GLuint supportedSamples) const; + + Blit11 *getBlitter() { return mBlit; } + Clear11 *getClearer() { return mClear; } + DebugAnnotatorContext11 *getDebugAnnotatorContext(); + + // Buffer-to-texture and Texture-to-buffer copies + bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override; + angle::Result fastCopyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) override; + + angle::Result packPixels(const gl::Context *context, + const TextureHelper11 &textureHelper, + const PackPixelsParams ¶ms, + uint8_t *pixelsOut); + + bool getLUID(LUID *adapterLuid) const override; + VertexConversionType getVertexConversionType(angle::FormatID vertexFormatID) const override; + GLenum getVertexComponentType(angle::FormatID vertexFormatID) const override; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + angle::Result getVertexSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *bytesRequiredOut) const override; + + angle::Result readFromAttachment(const gl::Context *context, + const gl::FramebufferAttachment &srcAttachment, + const gl::Rectangle &sourceArea, + GLenum format, + GLenum type, + GLuint outputPitch, + const gl::PixelPackState &pack, + uint8_t *pixels); + + angle::Result blitRenderbufferRect(const gl::Context *context, + const gl::Rectangle &readRect, + const gl::Rectangle &drawRect, + UINT readLayer, + UINT drawLayer, + RenderTargetD3D *readRenderTarget, + RenderTargetD3D *drawRenderTarget, + GLenum filter, + const gl::Rectangle *scissor, + bool colorBlit, + bool depthBlit, + bool stencilBlit); + + bool isES3Capable() const; + const Renderer11DeviceCaps &getRenderer11DeviceCaps() const { return mRenderer11DeviceCaps; } + + RendererClass getRendererClass() const override; + StateManager11 *getStateManager() { return &mStateManager; } + + void onSwap(); + void onBufferCreate(const Buffer11 *created); + void onBufferDelete(const Buffer11 *deleted); + + DeviceImpl *createEGLDevice() override; + + angle::Result drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexCount, + GLsizei instanceCount, + GLuint baseInstance, + bool isInstancedDraw); + angle::Result drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLint startVertex, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool isInstancedDraw); + angle::Result drawArraysIndirect(const gl::Context *context, const void *indirect); + angle::Result drawElementsIndirect(const gl::Context *context, const void *indirect); + + // Necessary hack for default framebuffers in D3D. + FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override; + + angle::Result getScratchMemoryBuffer(Context11 *context11, + size_t requestedSize, + angle::MemoryBuffer **bufferOut); + + gl::Version getMaxSupportedESVersion() const override; + gl::Version getMaxConformantESVersion() const override; + + angle::Result dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ); + angle::Result dispatchComputeIndirect(const gl::Context *context, GLintptr indirect); + + angle::Result createStagingTexture(const gl::Context *context, + ResourceType textureType, + const d3d11::Format &formatSet, + const gl::Extents &size, + StagingAccess readAndWriteAccess, + TextureHelper11 *textureOut); + + template <typename DescT, typename ResourceT> + angle::Result allocateResource(d3d::Context *context, const DescT &desc, ResourceT *resourceOut) + { + return mResourceManager11.allocate(context, this, &desc, nullptr, resourceOut); + } + + template <typename DescT, typename InitDataT, typename ResourceT> + angle::Result allocateResource(d3d::Context *context, + const DescT &desc, + InitDataT *initData, + ResourceT *resourceOut) + { + return mResourceManager11.allocate(context, this, &desc, initData, resourceOut); + } + + template <typename InitDataT, typename ResourceT> + angle::Result allocateResourceNoDesc(d3d::Context *context, + InitDataT *initData, + ResourceT *resourceOut) + { + return mResourceManager11.allocate(context, this, nullptr, initData, resourceOut); + } + + template <typename DescT> + angle::Result allocateTexture(d3d::Context *context, + const DescT &desc, + const d3d11::Format &format, + TextureHelper11 *textureOut) + { + return allocateTexture(context, desc, format, nullptr, textureOut); + } + + angle::Result allocateTexture(d3d::Context *context, + const D3D11_TEXTURE2D_DESC &desc, + const d3d11::Format &format, + const D3D11_SUBRESOURCE_DATA *initData, + TextureHelper11 *textureOut); + + angle::Result allocateTexture(d3d::Context *context, + const D3D11_TEXTURE3D_DESC &desc, + const d3d11::Format &format, + const D3D11_SUBRESOURCE_DATA *initData, + TextureHelper11 *textureOut); + + angle::Result clearRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget, + const gl::ColorF &clearColorValue, + const float clearDepthValue, + const unsigned int clearStencilValue) override; + + bool canSelectViewInVertexShader() const override; + + angle::Result mapResource(const gl::Context *context, + ID3D11Resource *resource, + UINT subResource, + D3D11_MAP mapType, + UINT mapFlags, + D3D11_MAPPED_SUBRESOURCE *mappedResource); + + angle::Result getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) override; + + void setGlobalDebugAnnotator() override; + + std::string getRendererDescription() const override; + std::string getVendorString() const override; + std::string getVersionString(bool includeFullVersion) const override; + + private: + void generateCaps(gl::Caps *outCaps, + gl::TextureCapsMap *outTextureCaps, + gl::Extensions *outExtensions, + gl::Limitations *outLimitations) const override; + + void initializeFeatures(angle::FeaturesD3D *features) const override; + + void initializeFrontendFeatures(angle::FrontendFeatures *features) const override; + + angle::Result drawLineLoop(const gl::Context *context, + GLuint count, + gl::DrawElementsType type, + const void *indices, + int baseVertex, + int instances); + angle::Result drawTriangleFan(const gl::Context *context, + GLuint count, + gl::DrawElementsType type, + const void *indices, + int baseVertex, + int instances); + + angle::Result resolveMultisampledTexture(const gl::Context *context, + RenderTarget11 *renderTarget, + bool depth, + bool stencil, + TextureHelper11 *textureOut); + + void populateRenderer11DeviceCaps(); + + void updateHistograms(); + + angle::Result copyImageInternal(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + RenderTargetD3D *destRenderTarget); + + gl::SupportedSampleSet generateSampleSetForEGLConfig( + const gl::TextureCaps &colorBufferFormatCaps, + const gl::TextureCaps &depthStencilBufferFormatCaps) const; + + HRESULT callD3D11CreateDevice(PFN_D3D11_CREATE_DEVICE createDevice, bool debug); + HRESULT callD3D11On12CreateDevice(PFN_D3D12_CREATE_DEVICE createDevice12, + PFN_D3D11ON12_CREATE_DEVICE createDevice11on12, + bool debug); + egl::Error initializeD3DDevice(); + egl::Error initializeDevice(); + void releaseDeviceResources(); + void release(); + + d3d11::ANGLED3D11DeviceType getDeviceType() const; + + // Make sure that the raw buffer is the latest buffer. + angle::Result markRawBufferUsage(const gl::Context *context); + angle::Result markTypedBufferUsage(const gl::Context *context); + angle::Result markTransformFeedbackUsage(const gl::Context *context); + angle::Result drawWithGeometryShaderAndTransformFeedback(Context11 *context11, + gl::PrimitiveMode mode, + UINT instanceCount, + UINT vertexCount); + + HMODULE mD3d11Module; + HMODULE mD3d12Module; + HMODULE mDxgiModule; + HMODULE mDCompModule; + std::vector<D3D_FEATURE_LEVEL> mAvailableFeatureLevels; + D3D_DRIVER_TYPE mRequestedDriverType; + bool mCreateDebugDevice; + bool mCreatedWithDeviceEXT; + + HLSLCompiler mCompiler; + + RenderStateCache mStateCache; + + StateManager11 mStateManager; + + StreamingIndexBufferInterface *mLineLoopIB; + StreamingIndexBufferInterface *mTriangleFanIB; + + // Texture copy resources + Blit11 *mBlit; + PixelTransfer11 *mPixelTransfer; + + // Masked clear resources + Clear11 *mClear; + + // Perform trim for D3D resources + Trim11 *mTrim; + + // Sync query + d3d11::Query mSyncQuery; + + // Created objects state tracking + std::set<const Buffer11 *> mAliveBuffers; + + double mLastHistogramUpdateTime; + + angle::ComPtr<ID3D12Device> mDevice12; + angle::ComPtr<ID3D12CommandQueue> mCommandQueue; + + ID3D11Device *mDevice; + ID3D11Device1 *mDevice1; + Renderer11DeviceCaps mRenderer11DeviceCaps; + ID3D11DeviceContext *mDeviceContext; + ID3D11DeviceContext1 *mDeviceContext1; + ID3D11DeviceContext3 *mDeviceContext3; + IDXGIAdapter *mDxgiAdapter; + DXGI_ADAPTER_DESC mAdapterDescription; + char mDescription[128]; + IDXGIFactory *mDxgiFactory; + ID3D11Debug *mDebug; + + std::vector<GLuint> mScratchIndexDataBuffer; + + angle::ScratchBuffer mScratchMemoryBuffer; + + DebugAnnotatorContext11 mAnnotatorContext; + + mutable Optional<bool> mSupportsShareHandles; + ResourceManager11 mResourceManager11; + + TextureHelper11 mCachedResolveTexture; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp new file mode 100644 index 0000000000..ebf2db497f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp @@ -0,0 +1,560 @@ +// +// Copyright 2017 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ResourceManager11: +// Centralized point of allocation for all D3D11 Resources. + +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +#include "common/debug.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" + +namespace rx +{ + +namespace +{ + +constexpr uint8_t kDebugInitTextureDataValue = 0x48; +constexpr FLOAT kDebugColorInitClearValue[4] = {0.3f, 0.5f, 0.7f, 0.5f}; +constexpr FLOAT kDebugDepthInitValue = 0.2f; +constexpr UINT8 kDebugStencilInitValue = 3; + +// A hard limit on buffer size. This works around a problem in the NVIDIA drivers where buffer sizes +// close to MAX_UINT would give undefined results. The limit of MAX_UINT/2 should be generous enough +// for almost any demanding application. +constexpr UINT kMaximumBufferSizeHardLimit = std::numeric_limits<UINT>::max() >> 1; + +uint64_t ComputeMippedMemoryUsage(unsigned int width, + unsigned int height, + unsigned int depth, + uint64_t pixelSize, + unsigned int mipLevels) +{ + uint64_t sizeSum = 0; + + for (unsigned int level = 0; level < mipLevels; ++level) + { + unsigned int mipWidth = std::max(width >> level, 1u); + unsigned int mipHeight = std::max(height >> level, 1u); + unsigned int mipDepth = std::max(depth >> level, 1u); + sizeSum += static_cast<uint64_t>(mipWidth * mipHeight * mipDepth) * pixelSize; + } + + return sizeSum; +} + +uint64_t ComputeMemoryUsage(const D3D11_TEXTURE2D_DESC *desc) +{ + ASSERT(desc); + uint64_t pixelBytes = + static_cast<uint64_t>(d3d11::GetDXGIFormatSizeInfo(desc->Format).pixelBytes); + return ComputeMippedMemoryUsage(desc->Width, desc->Height, 1, pixelBytes, desc->MipLevels); +} + +uint64_t ComputeMemoryUsage(const D3D11_TEXTURE3D_DESC *desc) +{ + ASSERT(desc); + uint64_t pixelBytes = + static_cast<uint64_t>(d3d11::GetDXGIFormatSizeInfo(desc->Format).pixelBytes); + return ComputeMippedMemoryUsage(desc->Width, desc->Height, desc->Depth, pixelBytes, + desc->MipLevels); +} + +uint64_t ComputeMemoryUsage(const D3D11_BUFFER_DESC *desc) +{ + ASSERT(desc); + return static_cast<uint64_t>(desc->ByteWidth); +} + +template <typename T> +uint64_t ComputeMemoryUsage(const T *desc) +{ + return 0; +} + +template <ResourceType ResourceT> +uint64_t ComputeGenericMemoryUsage(ID3D11DeviceChild *genericResource) +{ + auto *typedResource = static_cast<GetD3D11Type<ResourceT> *>(genericResource); + GetDescType<ResourceT> desc; + typedResource->GetDesc(&desc); + return ComputeMemoryUsage(&desc); +} + +uint64_t ComputeGenericMemoryUsage(ResourceType resourceType, ID3D11DeviceChild *resource) +{ + switch (resourceType) + { + case ResourceType::Texture2D: + return ComputeGenericMemoryUsage<ResourceType::Texture2D>(resource); + case ResourceType::Texture3D: + return ComputeGenericMemoryUsage<ResourceType::Texture3D>(resource); + case ResourceType::Buffer: + return ComputeGenericMemoryUsage<ResourceType::Buffer>(resource); + + default: + return 0; + } +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_BLEND_DESC *desc, + void * /*initData*/, + ID3D11BlendState **blendState) +{ + return device->CreateBlendState(desc, blendState); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_BUFFER_DESC *desc, + const D3D11_SUBRESOURCE_DATA *initData, + ID3D11Buffer **buffer) +{ + // Force buffers to be limited to a fixed max size. + if (desc->ByteWidth > kMaximumBufferSizeHardLimit) + { + return E_OUTOFMEMORY; + } + + return device->CreateBuffer(desc, initData, buffer); +} + +HRESULT CreateResource(ID3D11Device *device, + const ShaderData *desc, + void * /*initData*/, + ID3D11ComputeShader **resourceOut) +{ + return device->CreateComputeShader(desc->get(), desc->size(), nullptr, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_DEPTH_STENCIL_DESC *desc, + void * /*initData*/, + ID3D11DepthStencilState **resourceOut) +{ + return device->CreateDepthStencilState(desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, + ID3D11Resource *resource, + ID3D11DepthStencilView **resourceOut) +{ + return device->CreateDepthStencilView(resource, desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const ShaderData *desc, + const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData, + ID3D11GeometryShader **resourceOut) +{ + if (initData) + { + return device->CreateGeometryShaderWithStreamOutput( + desc->get(), desc->size(), initData->data(), static_cast<UINT>(initData->size()), + nullptr, 0, 0, nullptr, resourceOut); + } + else + { + return device->CreateGeometryShader(desc->get(), desc->size(), nullptr, resourceOut); + } +} + +HRESULT CreateResource(ID3D11Device *device, + const InputElementArray *desc, + const ShaderData *initData, + ID3D11InputLayout **resourceOut) +{ + return device->CreateInputLayout(desc->get(), static_cast<UINT>(desc->size()), initData->get(), + initData->size(), resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const ShaderData *desc, + void * /*initData*/, + ID3D11PixelShader **resourceOut) +{ + return device->CreatePixelShader(desc->get(), desc->size(), nullptr, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_QUERY_DESC *desc, + void * /*initData*/, + ID3D11Query **resourceOut) +{ + return device->CreateQuery(desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_RASTERIZER_DESC *desc, + void * /*initData*/, + ID3D11RasterizerState **rasterizerState) +{ + return device->CreateRasterizerState(desc, rasterizerState); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_RENDER_TARGET_VIEW_DESC *desc, + ID3D11Resource *resource, + ID3D11RenderTargetView **renderTargetView) +{ + return device->CreateRenderTargetView(resource, desc, renderTargetView); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_SAMPLER_DESC *desc, + void * /*initData*/, + ID3D11SamplerState **resourceOut) +{ + return device->CreateSamplerState(desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, + ID3D11Resource *resource, + ID3D11ShaderResourceView **resourceOut) +{ + return device->CreateShaderResourceView(resource, desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, + ID3D11Resource *resource, + ID3D11UnorderedAccessView **resourceOut) +{ + return device->CreateUnorderedAccessView(resource, desc, resourceOut); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_TEXTURE2D_DESC *desc, + const D3D11_SUBRESOURCE_DATA *initData, + ID3D11Texture2D **texture) +{ + return device->CreateTexture2D(desc, initData, texture); +} + +HRESULT CreateResource(ID3D11Device *device, + const D3D11_TEXTURE3D_DESC *desc, + const D3D11_SUBRESOURCE_DATA *initData, + ID3D11Texture3D **texture) +{ + return device->CreateTexture3D(desc, initData, texture); +} + +HRESULT CreateResource(ID3D11Device *device, + const ShaderData *desc, + void * /*initData*/, + ID3D11VertexShader **resourceOut) +{ + return device->CreateVertexShader(desc->get(), desc->size(), nullptr, resourceOut); +} + +DXGI_FORMAT GetTypedDepthStencilFormat(DXGI_FORMAT dxgiFormat) +{ + switch (dxgiFormat) + { + case DXGI_FORMAT_R16_TYPELESS: + return DXGI_FORMAT_D16_UNORM; + case DXGI_FORMAT_R24G8_TYPELESS: + return DXGI_FORMAT_D24_UNORM_S8_UINT; + case DXGI_FORMAT_R32_TYPELESS: + return DXGI_FORMAT_D32_FLOAT; + case DXGI_FORMAT_R32G8X24_TYPELESS: + return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; + default: + return dxgiFormat; + } +} + +template <typename DescT, typename ResourceT> +angle::Result ClearResource(d3d::Context *context, + Renderer11 *renderer, + const DescT *desc, + ResourceT *texture) +{ + // No-op. + return angle::Result::Continue; +} + +template <> +angle::Result ClearResource(d3d::Context *context, + Renderer11 *renderer, + const D3D11_TEXTURE2D_DESC *desc, + ID3D11Texture2D *texture) +{ + ID3D11DeviceContext *deviceContext = renderer->getDeviceContext(); + + if ((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) != 0) + { + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Flags = 0; + dsvDesc.Format = GetTypedDepthStencilFormat(desc->Format); + + const auto &format = d3d11_angle::GetFormat(dsvDesc.Format); + UINT clearFlags = (format.depthBits > 0 ? D3D11_CLEAR_DEPTH : 0) | + (format.stencilBits > 0 ? D3D11_CLEAR_STENCIL : 0); + + // Must process each mip level individually. + for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel) + { + if (desc->SampleDesc.Count == 0) + { + dsvDesc.Texture2D.MipSlice = mipLevel; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + } + else + { + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS; + } + + d3d11::DepthStencilView dsv; + ANGLE_TRY(renderer->allocateResource(context, dsvDesc, texture, &dsv)); + + deviceContext->ClearDepthStencilView(dsv.get(), clearFlags, kDebugDepthInitValue, + kDebugStencilInitValue); + } + } + else + { + ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0); + d3d11::RenderTargetView rtv; + ANGLE_TRY(renderer->allocateResourceNoDesc(context, texture, &rtv)); + + deviceContext->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue); + } + + return angle::Result::Continue; +} + +template <> +angle::Result ClearResource(d3d::Context *context, + Renderer11 *renderer, + const D3D11_TEXTURE3D_DESC *desc, + ID3D11Texture3D *texture) +{ + ID3D11DeviceContext *deviceContext = renderer->getDeviceContext(); + + ASSERT((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) == 0); + ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0); + + d3d11::RenderTargetView rtv; + ANGLE_TRY(renderer->allocateResourceNoDesc(context, texture, &rtv)); + + deviceContext->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue); + return angle::Result::Continue; +} + +#define ANGLE_RESOURCE_STRINGIFY_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + "Error allocating " #RESTYPE, + +constexpr std::array<const char *, NumResourceTypes> kResourceTypeErrors = { + {ANGLE_RESOURCE_TYPE_OP(Stringify, ANGLE_RESOURCE_STRINGIFY_OP)}}; +static_assert(kResourceTypeErrors[NumResourceTypes - 1] != nullptr, + "All members must be initialized."); + +} // anonymous namespace + +// ResourceManager11 Implementation. +ResourceManager11::ResourceManager11() : mInitializeAllocations(false) +{ + for (auto &count : mAllocatedResourceCounts) + { + count = 0; + } + for (auto &memorySize : mAllocatedResourceDeviceMemory) + { + memorySize = 0; + } +} + +ResourceManager11::~ResourceManager11() +{ + for (size_t count : mAllocatedResourceCounts) + { + ASSERT(count == 0); + } + + for (uint64_t memorySize : mAllocatedResourceDeviceMemory) + { + ASSERT(memorySize == 0); + } +} + +template <typename T> +angle::Result ResourceManager11::allocate(d3d::Context *context, + Renderer11 *renderer, + const GetDescFromD3D11<T> *desc, + GetInitDataFromD3D11<T> *initData, + Resource11<T> *resourceOut) +{ + ID3D11Device *device = renderer->getDevice(); + T *resource = nullptr; + + GetInitDataFromD3D11<T> *shadowInitData = initData; + if (!shadowInitData && mInitializeAllocations) + { + shadowInitData = createInitDataIfNeeded<T>(desc); + } + + HRESULT hr = CreateResource(device, desc, shadowInitData, &resource); + ANGLE_TRY_HR(context, hr, kResourceTypeErrors[ResourceTypeIndex<T>()]); + + if (!shadowInitData && mInitializeAllocations) + { + ANGLE_TRY(ClearResource(context, renderer, desc, resource)); + } + + ASSERT(resource); + incrResource(GetResourceTypeFromD3D11<T>(), ComputeMemoryUsage(desc)); + *resourceOut = std::move(Resource11<T>(resource, this)); + return angle::Result::Continue; +} + +void ResourceManager11::incrResource(ResourceType resourceType, uint64_t memorySize) +{ + size_t typeIndex = ResourceTypeIndex(resourceType); + + mAllocatedResourceCounts[typeIndex]++; + mAllocatedResourceDeviceMemory[typeIndex] += memorySize; + + // This checks for integer overflow. + ASSERT(mAllocatedResourceCounts[typeIndex] > 0); + ASSERT(mAllocatedResourceDeviceMemory[typeIndex] >= memorySize); +} + +void ResourceManager11::decrResource(ResourceType resourceType, uint64_t memorySize) +{ + size_t typeIndex = ResourceTypeIndex(resourceType); + + ASSERT(mAllocatedResourceCounts[typeIndex] > 0); + mAllocatedResourceCounts[typeIndex]--; + ASSERT(mAllocatedResourceDeviceMemory[typeIndex] >= memorySize); + mAllocatedResourceDeviceMemory[typeIndex] -= memorySize; +} + +void ResourceManager11::onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource) +{ + ASSERT(resource); + decrResource(resourceType, ComputeGenericMemoryUsage(resourceType, resource)); +} + +template <> +const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Texture2D>( + const D3D11_TEXTURE2D_DESC *desc) +{ + ASSERT(desc); + + if ((desc->BindFlags & (D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_RENDER_TARGET)) != 0) + { + // This will be done using ClearView methods. + return nullptr; + } + + size_t requiredSize = static_cast<size_t>(ComputeMemoryUsage(desc)); + if (mZeroMemory.size() < requiredSize) + { + if (!mZeroMemory.resize(requiredSize)) + { + ERR() << "Failed to allocate D3D texture initialization data."; + return nullptr; + } + mZeroMemory.fill(kDebugInitTextureDataValue); + } + + const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format); + + UINT subresourceCount = desc->MipLevels * desc->ArraySize; + if (mShadowInitData.size() < subresourceCount) + { + mShadowInitData.resize(subresourceCount); + } + + for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel) + { + for (UINT arrayIndex = 0; arrayIndex < desc->ArraySize; ++arrayIndex) + { + UINT subresourceIndex = D3D11CalcSubresource(mipLevel, arrayIndex, desc->MipLevels); + D3D11_SUBRESOURCE_DATA *data = &mShadowInitData[subresourceIndex]; + + UINT levelWidth = std::max(desc->Width >> mipLevel, 1u); + UINT levelHeight = std::max(desc->Height >> mipLevel, 1u); + + data->SysMemPitch = levelWidth * formatSizeInfo.pixelBytes; + data->SysMemSlicePitch = data->SysMemPitch * levelHeight; + data->pSysMem = mZeroMemory.data(); + } + } + + return mShadowInitData.data(); +} + +template <> +const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Texture3D>( + const D3D11_TEXTURE3D_DESC *desc) +{ + ASSERT(desc); + + if ((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0) + { + // This will be done using ClearView methods. + return nullptr; + } + + size_t requiredSize = static_cast<size_t>(ComputeMemoryUsage(desc)); + if (mZeroMemory.size() < requiredSize) + { + if (!mZeroMemory.resize(requiredSize)) + { + ERR() << "Failed to allocate D3D texture initialization data."; + return nullptr; + } + mZeroMemory.fill(kDebugInitTextureDataValue); + } + + const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format); + + UINT subresourceCount = desc->MipLevels; + if (mShadowInitData.size() < subresourceCount) + { + mShadowInitData.resize(subresourceCount); + } + + for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel) + { + UINT subresourceIndex = D3D11CalcSubresource(mipLevel, 0, desc->MipLevels); + D3D11_SUBRESOURCE_DATA *data = &mShadowInitData[subresourceIndex]; + + UINT levelWidth = std::max(desc->Width >> mipLevel, 1u); + UINT levelHeight = std::max(desc->Height >> mipLevel, 1u); + + data->SysMemPitch = levelWidth * formatSizeInfo.pixelBytes; + data->SysMemSlicePitch = data->SysMemPitch * levelHeight; + data->pSysMem = mZeroMemory.data(); + } + + return mShadowInitData.data(); +} + +template <typename T> +GetInitDataFromD3D11<T> *ResourceManager11::createInitDataIfNeeded(const GetDescFromD3D11<T> *desc) +{ + // No-op. + return nullptr; +} + +void ResourceManager11::setAllocationsInitialized(bool initialize) +{ + mInitializeAllocations = initialize; +} + +#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + \ + template angle::Result ResourceManager11::allocate( \ + d3d::Context *, Renderer11 *, const DESCTYPE *, INITDATATYPE *, Resource11<D3D11TYPE> *); + +ANGLE_RESOURCE_TYPE_OP(Instantitate, ANGLE_INSTANTIATE_OP) +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h new file mode 100644 index 0000000000..b013ab8358 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h @@ -0,0 +1,411 @@ +// +// Copyright 2017 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ResourceManager11: +// Centralized point of allocation for all D3D11 Resources. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_RESOURCEFACTORY11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_RESOURCEFACTORY11_H_ + +#include <array> +#include <atomic> +#include <memory> + +#include "common/MemoryBuffer.h" +#include "common/angleutils.h" +#include "common/debug.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/serial_utils.h" + +namespace rx +{ +// These two methods are declared here to prevent circular includes. +namespace d3d11 +{ +HRESULT SetDebugName(ID3D11DeviceChild *resource, + const char *internalName, + const std::string *khrDebugName); + +template <typename T> +HRESULT SetDebugName(angle::ComPtr<T> &resource, + const char *internalName, + const std::string *khrDebugName) +{ + return SetDebugName(resource.Get(), internalName, khrDebugName); +} +} // namespace d3d11 + +namespace d3d +{ +class Context; +} // namespace d3d + +class Renderer11; +class ResourceManager11; +template <typename T> +class SharedResource11; +class TextureHelper11; + +using InputElementArray = WrappedArray<D3D11_INPUT_ELEMENT_DESC>; +using ShaderData = WrappedArray<uint8_t>; + +// Format: ResourceType, D3D11 type, DESC type, init data type. +#define ANGLE_RESOURCE_TYPE_OP(NAME, OP) \ + OP(NAME, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void) \ + OP(NAME, Buffer, ID3D11Buffer, D3D11_BUFFER_DESC, const D3D11_SUBRESOURCE_DATA) \ + OP(NAME, ComputeShader, ID3D11ComputeShader, ShaderData, void) \ + OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void) \ + OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC, \ + ID3D11Resource) \ + OP(NAME, GeometryShader, ID3D11GeometryShader, ShaderData, \ + const std::vector<D3D11_SO_DECLARATION_ENTRY>) \ + OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData) \ + OP(NAME, PixelShader, ID3D11PixelShader, ShaderData, void) \ + OP(NAME, Query, ID3D11Query, D3D11_QUERY_DESC, void) \ + OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void) \ + OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC, \ + ID3D11Resource) \ + OP(NAME, SamplerState, ID3D11SamplerState, D3D11_SAMPLER_DESC, void) \ + OP(NAME, ShaderResourceView, ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC, \ + ID3D11Resource) \ + OP(NAME, UnorderedAccessView, ID3D11UnorderedAccessView, D3D11_UNORDERED_ACCESS_VIEW_DESC, \ + ID3D11Resource) \ + OP(NAME, Texture2D, ID3D11Texture2D, D3D11_TEXTURE2D_DESC, const D3D11_SUBRESOURCE_DATA) \ + OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA) \ + OP(NAME, VertexShader, ID3D11VertexShader, ShaderData, void) + +#define ANGLE_RESOURCE_TYPE_LIST(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) RESTYPE, + +enum class ResourceType +{ + ANGLE_RESOURCE_TYPE_OP(List, ANGLE_RESOURCE_TYPE_LIST) Last +}; + +#undef ANGLE_RESOURCE_TYPE_LIST + +constexpr size_t ResourceTypeIndex(ResourceType resourceType) +{ + return static_cast<size_t>(resourceType); +} + +constexpr size_t NumResourceTypes = ResourceTypeIndex(ResourceType::Last); + +#define ANGLE_RESOURCE_TYPE_TO_D3D11(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + \ + template <> \ + struct NAME<ResourceType::RESTYPE> \ + { \ + using Value = D3D11TYPE; \ + }; + +#define ANGLE_RESOURCE_TYPE_TO_DESC(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + \ + template <> \ + struct NAME<ResourceType::RESTYPE> \ + { \ + using Value = DESCTYPE; \ + }; + +#define ANGLE_RESOURCE_TYPE_TO_INIT_DATA(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + \ + template <> \ + struct NAME<ResourceType::RESTYPE> \ + { \ + using Value = INITDATATYPE; \ + }; + +#define ANGLE_RESOURCE_TYPE_TO_TYPE(NAME, OP) \ + template <ResourceType Param> \ + struct NAME; \ + ANGLE_RESOURCE_TYPE_OP(NAME, OP) \ + \ + template <ResourceType Param> \ + struct NAME \ + {}; \ + \ + template <ResourceType Param> \ + using Get##NAME = typename NAME<Param>::Value; + +ANGLE_RESOURCE_TYPE_TO_TYPE(D3D11Type, ANGLE_RESOURCE_TYPE_TO_D3D11) +ANGLE_RESOURCE_TYPE_TO_TYPE(DescType, ANGLE_RESOURCE_TYPE_TO_DESC) +ANGLE_RESOURCE_TYPE_TO_TYPE(InitDataType, ANGLE_RESOURCE_TYPE_TO_INIT_DATA) + +#undef ANGLE_RESOURCE_TYPE_TO_D3D11 +#undef ANGLE_RESOURCE_TYPE_TO_DESC +#undef ANGLE_RESOURCE_TYPE_TO_INIT_DATA +#undef ANGLE_RESOURCE_TYPE_TO_TYPE + +#define ANGLE_TYPE_TO_RESOURCE_TYPE(NAME, OP) \ + template <typename Param> \ + struct NAME; \ + ANGLE_RESOURCE_TYPE_OP(NAME, OP) \ + \ + template <typename Param> \ + struct NAME \ + {}; \ + \ + template <typename Param> \ + constexpr ResourceType Get##NAME() \ + { \ + return NAME<Param>::Value; \ + } + +#define ANGLE_D3D11_TO_RESOURCE_TYPE(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + \ + template <> \ + struct NAME<D3D11TYPE> \ + { \ + static constexpr ResourceType Value = ResourceType::RESTYPE; \ + }; + +ANGLE_TYPE_TO_RESOURCE_TYPE(ResourceTypeFromD3D11, ANGLE_D3D11_TO_RESOURCE_TYPE) + +#undef ANGLE_D3D11_TO_RESOURCE_TYPE +#undef ANGLE_TYPE_TO_RESOURCE_TYPE + +template <typename T> +using GetDescFromD3D11 = GetDescType<ResourceTypeFromD3D11<T>::Value>; + +template <typename T> +using GetInitDataFromD3D11 = GetInitDataType<ResourceTypeFromD3D11<T>::Value>; + +template <typename T> +constexpr size_t ResourceTypeIndex() +{ + return static_cast<size_t>(GetResourceTypeFromD3D11<T>()); +} + +template <typename T> +struct TypedData +{ + TypedData() {} + ~TypedData(); + + T *object = nullptr; + ResourceManager11 *manager = nullptr; +}; + +// Smart pointer type. Wraps the resource and a factory for safe deletion. +template <typename T, template <class> class Pointer, typename DataT> +class Resource11Base : angle::NonCopyable +{ + public: + T *get() const { return mData->object; } + T *const *getPointer() const { return &mData->object; } + + void setInternalName(const char *name) + { + mInternalDebugName = name; + UpdateDebugNameWithD3D(); + } + + void setKHRDebugLabel(const std::string *label) + { + mKhrDebugName = label; + UpdateDebugNameWithD3D(); + } + + void setLabels(const char *name, const std::string *label) + { + mInternalDebugName = name; + mKhrDebugName = label; + UpdateDebugNameWithD3D(); + } + + void set(T *object) + { + ASSERT(!valid()); + mData->object = object; + } + + bool valid() const { return (mData->object != nullptr); } + + void reset() + { + if (valid()) + mData.reset(new DataT()); + } + + ResourceSerial getSerial() const + { + return ResourceSerial(reinterpret_cast<uintptr_t>(mData->object)); + } + + protected: + friend class TextureHelper11; + + Resource11Base() : mData(new DataT()) {} + + Resource11Base(Resource11Base &&movedObj) : mData(new DataT()) + { + std::swap(mData, movedObj.mData); + } + + virtual ~Resource11Base() { mData.reset(); } + + Resource11Base &operator=(Resource11Base &&movedObj) + { + std::swap(mData, movedObj.mData); + return *this; + } + + Pointer<DataT> mData; + + private: + void UpdateDebugNameWithD3D() + { + d3d11::SetDebugName(mData->object, mInternalDebugName, mKhrDebugName); + } + + const std::string *mKhrDebugName = nullptr; + const char *mInternalDebugName = nullptr; +}; + +template <typename T> +using UniquePtr = typename std::unique_ptr<T, std::default_delete<T>>; + +template <typename ResourceT> +class Resource11 : public Resource11Base<ResourceT, UniquePtr, TypedData<ResourceT>> +{ + public: + Resource11() {} + Resource11(Resource11 &&other) + : Resource11Base<ResourceT, UniquePtr, TypedData<ResourceT>>(std::move(other)) + {} + Resource11 &operator=(Resource11 &&other) + { + std::swap(this->mData, other.mData); + return *this; + } + + private: + template <typename T> + friend class SharedResource11; + friend class ResourceManager11; + + Resource11(ResourceT *object, ResourceManager11 *manager) + { + this->mData->object = object; + this->mData->manager = manager; + } +}; + +template <typename T> +class SharedResource11 : public Resource11Base<T, std::shared_ptr, TypedData<T>> +{ + public: + SharedResource11() {} + SharedResource11(SharedResource11 &&movedObj) + : Resource11Base<T, std::shared_ptr, TypedData<T>>(std::move(movedObj)) + {} + + SharedResource11 &operator=(SharedResource11 &&other) + { + std::swap(this->mData, other.mData); + return *this; + } + + SharedResource11 makeCopy() const + { + SharedResource11 copy; + copy.mData = this->mData; + return std::move(copy); + } + + private: + friend class ResourceManager11; + SharedResource11(Resource11<T> &&obj) : Resource11Base<T, std::shared_ptr, TypedData<T>>() + { + std::swap(this->mData->manager, obj.mData->manager); + + // Can't use std::swap because of ID3D11Resource. + auto temp = this->mData->object; + this->mData->object = obj.mData->object; + obj.mData->object = static_cast<T *>(temp); + } +}; + +class ResourceManager11 final : angle::NonCopyable +{ + public: + ResourceManager11(); + ~ResourceManager11(); + + template <typename T> + angle::Result allocate(d3d::Context *context, + Renderer11 *renderer, + const GetDescFromD3D11<T> *desc, + GetInitDataFromD3D11<T> *initData, + Resource11<T> *resourceOut); + + template <typename T> + angle::Result allocate(d3d::Context *context, + Renderer11 *renderer, + const GetDescFromD3D11<T> *desc, + GetInitDataFromD3D11<T> *initData, + SharedResource11<T> *sharedRes) + { + Resource11<T> res; + ANGLE_TRY(allocate(context, renderer, desc, initData, &res)); + *sharedRes = std::move(res); + return angle::Result::Continue; + } + + template <typename T> + void onRelease(T *resource) + { + onReleaseGeneric(GetResourceTypeFromD3D11<T>(), resource); + } + + void onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource); + + void setAllocationsInitialized(bool initialize); + + private: + void incrResource(ResourceType resourceType, uint64_t memorySize); + void decrResource(ResourceType resourceType, uint64_t memorySize); + + template <typename T> + GetInitDataFromD3D11<T> *createInitDataIfNeeded(const GetDescFromD3D11<T> *desc); + + bool mInitializeAllocations; + + std::array<std::atomic_size_t, NumResourceTypes> mAllocatedResourceCounts; + std::array<std::atomic_uint64_t, NumResourceTypes> mAllocatedResourceDeviceMemory; + angle::MemoryBuffer mZeroMemory; + + std::vector<D3D11_SUBRESOURCE_DATA> mShadowInitData; +}; + +template <typename ResourceT> +TypedData<ResourceT>::~TypedData() +{ + if (object) + { + // We can have a nullptr factory when holding passed-in resources. + if (manager) + { + manager->onRelease(object); + } + object->Release(); + } +} + +#define ANGLE_RESOURCE_TYPE_CLASS(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \ + using RESTYPE = Resource11<D3D11TYPE>; + +namespace d3d11 +{ +ANGLE_RESOURCE_TYPE_OP(ClassList, ANGLE_RESOURCE_TYPE_CLASS) + +using SharedSRV = SharedResource11<ID3D11ShaderResourceView>; +using SharedUAV = SharedResource11<ID3D11UnorderedAccessView>; +} // namespace d3d11 + +#undef ANGLE_RESOURCE_TYPE_CLASS + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_RESOURCEFACTORY11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp new file mode 100644 index 0000000000..a30ca417c1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp @@ -0,0 +1,116 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable11.cpp: Implements a D3D11-specific class to contain shader +// executable implementation details. + +#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +ShaderExecutable11::ShaderExecutable11(const void *function, + size_t length, + d3d11::PixelShader &&executable) + : ShaderExecutableD3D(function, length), + mPixelExecutable(std::move(executable)), + mVertexExecutable(), + mGeometryExecutable(), + mStreamOutExecutable(), + mComputeExecutable() +{} + +ShaderExecutable11::ShaderExecutable11(const void *function, + size_t length, + d3d11::VertexShader &&executable, + d3d11::GeometryShader &&streamOut) + : ShaderExecutableD3D(function, length), + mPixelExecutable(), + mVertexExecutable(std::move(executable)), + mGeometryExecutable(), + mStreamOutExecutable(std::move(streamOut)), + mComputeExecutable() +{} + +ShaderExecutable11::ShaderExecutable11(const void *function, + size_t length, + d3d11::GeometryShader &&executable) + : ShaderExecutableD3D(function, length), + mPixelExecutable(), + mVertexExecutable(), + mGeometryExecutable(std::move(executable)), + mStreamOutExecutable(), + mComputeExecutable() +{} + +ShaderExecutable11::ShaderExecutable11(const void *function, + size_t length, + d3d11::ComputeShader &&executable) + : ShaderExecutableD3D(function, length), + mPixelExecutable(), + mVertexExecutable(), + mGeometryExecutable(), + mStreamOutExecutable(), + mComputeExecutable(std::move(executable)) +{} + +ShaderExecutable11::~ShaderExecutable11() {} + +const d3d11::VertexShader &ShaderExecutable11::getVertexShader() const +{ + return mVertexExecutable; +} + +const d3d11::PixelShader &ShaderExecutable11::getPixelShader() const +{ + return mPixelExecutable; +} + +const d3d11::GeometryShader &ShaderExecutable11::getGeometryShader() const +{ + return mGeometryExecutable; +} + +const d3d11::GeometryShader &ShaderExecutable11::getStreamOutShader() const +{ + return mStreamOutExecutable; +} + +const d3d11::ComputeShader &ShaderExecutable11::getComputeShader() const +{ + return mComputeExecutable; +} + +UniformStorage11::UniformStorage11(size_t initialSize) + : UniformStorageD3D(initialSize), mConstantBuffer() +{} + +UniformStorage11::~UniformStorage11() {} + +angle::Result UniformStorage11::getConstantBuffer(const gl::Context *context, + Renderer11 *renderer, + const d3d11::Buffer **bufferOut) +{ + if (size() > 0 && !mConstantBuffer.valid()) + { + D3D11_BUFFER_DESC desc = {}; + desc.ByteWidth = static_cast<unsigned int>(size()); + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + + ANGLE_TRY( + renderer->allocateResource(GetImplAs<Context11>(context), desc, &mConstantBuffer)); + } + + *bufferOut = &mConstantBuffer; + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h new file mode 100644 index 0000000000..75c71b3238 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h @@ -0,0 +1,69 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable11.h: Defines a D3D11-specific class to contain shader +// executable implementation details. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_SHADEREXECUTABLE11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_SHADEREXECUTABLE11_H_ + +#include "libANGLE/renderer/d3d/ShaderExecutableD3D.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace gl +{ +class Context; +} // namespace gl + +namespace rx +{ +class Renderer11; +class UniformStorage11; + +class ShaderExecutable11 : public ShaderExecutableD3D +{ + public: + ShaderExecutable11(const void *function, size_t length, d3d11::PixelShader &&executable); + ShaderExecutable11(const void *function, + size_t length, + d3d11::VertexShader &&executable, + d3d11::GeometryShader &&streamOut); + ShaderExecutable11(const void *function, size_t length, d3d11::GeometryShader &&executable); + ShaderExecutable11(const void *function, size_t length, d3d11::ComputeShader &&executable); + + ~ShaderExecutable11() override; + + const d3d11::PixelShader &getPixelShader() const; + const d3d11::VertexShader &getVertexShader() const; + const d3d11::GeometryShader &getGeometryShader() const; + const d3d11::GeometryShader &getStreamOutShader() const; + const d3d11::ComputeShader &getComputeShader() const; + + private: + d3d11::PixelShader mPixelExecutable; + d3d11::VertexShader mVertexExecutable; + d3d11::GeometryShader mGeometryExecutable; + d3d11::GeometryShader mStreamOutExecutable; + d3d11::ComputeShader mComputeExecutable; +}; + +class UniformStorage11 : public UniformStorageD3D +{ + public: + UniformStorage11(size_t initialSize); + ~UniformStorage11() override; + + angle::Result getConstantBuffer(const gl::Context *context, + Renderer11 *renderer, + const d3d11::Buffer **bufferOut); + + private: + d3d11::Buffer mConstantBuffer; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_SHADEREXECUTABLE11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp new file mode 100644 index 0000000000..194c89d1c7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp @@ -0,0 +1,4004 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StateManager11.cpp: Defines a class for caching D3D11 state + +#include "libANGLE/renderer/d3d/d3d11/StateManager11.h" + +#include "common/angleutils.h" +#include "common/bitset_utils.h" +#include "common/mathutil.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Query.h" +#include "libANGLE/Surface.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/IndexBuffer11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h" +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" +#include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h" + +namespace rx +{ + +namespace +{ +bool ImageIndexConflictsWithSRV(const gl::ImageIndex &index, D3D11_SHADER_RESOURCE_VIEW_DESC desc) +{ + unsigned mipLevel = index.getLevelIndex(); + gl::TextureType textureType = index.getType(); + + switch (desc.ViewDimension) + { + case D3D11_SRV_DIMENSION_TEXTURE2D: + { + bool allLevels = (desc.Texture2D.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.Texture2D.MipLevels + desc.Texture2D.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; + + unsigned mipMin = index.getLevelIndex(); + unsigned mipMax = INT_MAX; + + return textureType == gl::TextureType::_2D && + gl::RangeUI(mipMin, mipMax) + .intersects(gl::RangeUI(desc.Texture2D.MostDetailedMip, maxSrvMip)); + } + + case D3D11_SRV_DIMENSION_TEXTURE2DARRAY: + { + GLint layerIndex = index.getLayerIndex(); + + bool allLevels = (desc.Texture2DArray.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = + desc.Texture2DArray.MipLevels + desc.Texture2DArray.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; + + unsigned maxSlice = desc.Texture2DArray.FirstArraySlice + desc.Texture2DArray.ArraySize; + + // Cube maps can be mapped to Texture2DArray SRVs + return (textureType == gl::TextureType::_2DArray || + textureType == gl::TextureType::CubeMap) && + desc.Texture2DArray.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip && + desc.Texture2DArray.FirstArraySlice <= static_cast<UINT>(layerIndex) && + static_cast<UINT>(layerIndex) < maxSlice; + } + + case D3D11_SRV_DIMENSION_TEXTURECUBE: + { + bool allLevels = (desc.TextureCube.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.TextureCube.MipLevels + desc.TextureCube.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; + + return textureType == gl::TextureType::CubeMap && + desc.TextureCube.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip; + } + + case D3D11_SRV_DIMENSION_TEXTURE3D: + { + bool allLevels = (desc.Texture3D.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.Texture3D.MipLevels + desc.Texture3D.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; + + return textureType == gl::TextureType::_3D && + desc.Texture3D.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip; + } + default: + // We only handle the cases corresponding to valid image indexes + UNIMPLEMENTED(); + } + + return false; +} + +bool ImageIndexConflictsWithUAV(const gl::ImageIndex &index, D3D11_UNORDERED_ACCESS_VIEW_DESC desc) +{ + unsigned mipLevel = index.getLevelIndex(); + gl::TextureType textureType = index.getType(); + + switch (desc.ViewDimension) + { + case D3D11_UAV_DIMENSION_TEXTURE2D: + { + return textureType == gl::TextureType::_2D && mipLevel == desc.Texture2D.MipSlice; + } + + case D3D11_UAV_DIMENSION_TEXTURE2DARRAY: + { + GLint layerIndex = index.getLayerIndex(); + unsigned mipSlice = desc.Texture2DArray.MipSlice; + unsigned firstArraySlice = desc.Texture2DArray.FirstArraySlice; + unsigned lastArraySlice = firstArraySlice + desc.Texture2DArray.ArraySize; + + return (textureType == gl::TextureType::_2DArray || + textureType == gl::TextureType::CubeMap) && + (mipLevel == mipSlice && gl::RangeUI(firstArraySlice, lastArraySlice) + .contains(static_cast<UINT>(layerIndex))); + } + + case D3D11_UAV_DIMENSION_TEXTURE3D: + { + GLint layerIndex = index.getLayerIndex(); + unsigned mipSlice = desc.Texture3D.MipSlice; + unsigned firstWSlice = desc.Texture3D.FirstWSlice; + unsigned lastWSlice = firstWSlice + desc.Texture3D.WSize; + + return textureType == gl::TextureType::_3D && + (mipLevel == mipSlice && + gl::RangeUI(firstWSlice, lastWSlice).contains(static_cast<UINT>(layerIndex))); + } + default: + return false; + } +} + +// Does *not* increment the resource ref count!! +ID3D11Resource *GetViewResource(ID3D11View *view) +{ + ID3D11Resource *resource = nullptr; + ASSERT(view); + view->GetResource(&resource); + resource->Release(); + return resource; +} + +int GetWrapBits(GLenum wrap) +{ + switch (wrap) + { + case GL_CLAMP_TO_EDGE: + return 0x0; + case GL_REPEAT: + return 0x1; + case GL_MIRRORED_REPEAT: + return 0x2; + case GL_CLAMP_TO_BORDER: + return 0x3; + default: + UNREACHABLE(); + return 0; + } +} + +Optional<size_t> FindFirstNonInstanced( + const std::vector<const TranslatedAttribute *> ¤tAttributes) +{ + for (size_t index = 0; index < currentAttributes.size(); ++index) + { + if (currentAttributes[index]->divisor == 0) + { + return Optional<size_t>(index); + } + } + + return Optional<size_t>::Invalid(); +} + +void SortAttributesByLayout(const ProgramD3D &programD3D, + const std::vector<TranslatedAttribute> &vertexArrayAttribs, + const std::vector<TranslatedAttribute> ¤tValueAttribs, + AttribIndexArray *sortedD3DSemanticsOut, + std::vector<const TranslatedAttribute *> *sortedAttributesOut) +{ + sortedAttributesOut->clear(); + + const AttribIndexArray &locationToSemantic = programD3D.getAttribLocationToD3DSemantics(); + const gl::ProgramExecutable &executable = programD3D.getState().getExecutable(); + + for (auto locationIndex : executable.getActiveAttribLocationsMask()) + { + int d3dSemantic = locationToSemantic[locationIndex]; + if (sortedAttributesOut->size() <= static_cast<size_t>(d3dSemantic)) + { + sortedAttributesOut->resize(d3dSemantic + 1); + } + + (*sortedD3DSemanticsOut)[d3dSemantic] = d3dSemantic; + + const auto *arrayAttrib = &vertexArrayAttribs[locationIndex]; + if (arrayAttrib->attribute && arrayAttrib->attribute->enabled) + { + (*sortedAttributesOut)[d3dSemantic] = arrayAttrib; + } + else + { + ASSERT(currentValueAttribs[locationIndex].attribute); + (*sortedAttributesOut)[d3dSemantic] = ¤tValueAttribs[locationIndex]; + } + } +} + +void UpdateUniformBuffer(ID3D11DeviceContext *deviceContext, + UniformStorage11 *storage, + const d3d11::Buffer *buffer) +{ + deviceContext->UpdateSubresource(buffer->get(), 0, nullptr, storage->getDataPointer(0, 0), 0, + 0); +} + +size_t GetReservedBufferCount(bool usesPointSpriteEmulation) +{ + return usesPointSpriteEmulation ? 1 : 0; +} + +bool CullsEverything(const gl::State &glState) +{ + return (glState.getRasterizerState().cullFace && + glState.getRasterizerState().cullMode == gl::CullFaceMode::FrontAndBack); +} +} // anonymous namespace + +// StateManager11::ViewCache Implementation. +template <typename ViewType, typename DescType> +StateManager11::ViewCache<ViewType, DescType>::ViewCache() : mHighestUsedView(0) +{} + +template <typename ViewType, typename DescType> +StateManager11::ViewCache<ViewType, DescType>::~ViewCache() +{} + +template <typename ViewType, typename DescType> +void StateManager11::ViewCache<ViewType, DescType>::update(size_t resourceIndex, ViewType *view) +{ + ASSERT(resourceIndex < mCurrentViews.size()); + ViewRecord<DescType> *record = &mCurrentViews[resourceIndex]; + + record->view = reinterpret_cast<uintptr_t>(view); + if (view) + { + record->resource = reinterpret_cast<uintptr_t>(GetViewResource(view)); + view->GetDesc(&record->desc); + mHighestUsedView = std::max(resourceIndex + 1, mHighestUsedView); + } + else + { + record->resource = 0; + + if (resourceIndex + 1 == mHighestUsedView) + { + do + { + --mHighestUsedView; + } while (mHighestUsedView > 0 && mCurrentViews[mHighestUsedView].view == 0); + } + } +} + +template <typename ViewType, typename DescType> +void StateManager11::ViewCache<ViewType, DescType>::clear() +{ + if (mCurrentViews.empty()) + { + return; + } + + memset(&mCurrentViews[0], 0, sizeof(ViewRecord<DescType>) * mCurrentViews.size()); + mHighestUsedView = 0; +} + +StateManager11::SRVCache *StateManager11::getSRVCache(gl::ShaderType shaderType) +{ + ASSERT(shaderType != gl::ShaderType::InvalidEnum); + return &mCurShaderSRVs[shaderType]; +} + +// ShaderConstants11 implementation +ShaderConstants11::ShaderConstants11() : mNumActiveShaderSamplers({}) +{ + mShaderConstantsDirty.set(); +} + +ShaderConstants11::~ShaderConstants11() {} + +void ShaderConstants11::init(const gl::Caps &caps) +{ + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + mShaderSamplerMetadata[shaderType].resize(caps.maxShaderTextureImageUnits[shaderType]); + mShaderReadonlyImageMetadata[shaderType].resize(caps.maxShaderImageUniforms[shaderType]); + mShaderImageMetadata[shaderType].resize(caps.maxShaderImageUniforms[shaderType]); + } +} + +size_t ShaderConstants11::GetShaderConstantsStructSize(gl::ShaderType shaderType) +{ + switch (shaderType) + { + case gl::ShaderType::Vertex: + return sizeof(Vertex); + case gl::ShaderType::Fragment: + return sizeof(Pixel); + case gl::ShaderType::Compute: + return sizeof(Compute); + + // TODO(jiawei.shao@intel.com): return geometry shader constant struct size + case gl::ShaderType::Geometry: + return 0u; + + default: + UNREACHABLE(); + return 0u; + } +} + +size_t ShaderConstants11::getRequiredBufferSize(gl::ShaderType shaderType) const +{ + ASSERT(shaderType != gl::ShaderType::InvalidEnum); + return GetShaderConstantsStructSize(shaderType) + + mShaderSamplerMetadata[shaderType].size() * sizeof(SamplerMetadata) + + mShaderImageMetadata[shaderType].size() * sizeof(ImageMetadata) + + mShaderReadonlyImageMetadata[shaderType].size() * sizeof(ImageMetadata); +} + +void ShaderConstants11::markDirty() +{ + mShaderConstantsDirty.set(); + mNumActiveShaderSamplers.fill(0); +} + +bool ShaderConstants11::updateSamplerMetadata(SamplerMetadata *data, + const gl::Texture &texture, + const gl::SamplerState &samplerState) +{ + bool dirty = false; + unsigned int baseLevel = texture.getTextureState().getEffectiveBaseLevel(); + gl::TextureTarget target = (texture.getType() == gl::TextureType::CubeMap) + ? gl::kCubeMapTextureTargetMin + : gl::NonCubeTextureTypeToTarget(texture.getType()); + GLenum sizedFormat = texture.getFormat(target, baseLevel).info->sizedInternalFormat; + if (data->baseLevel != static_cast<int>(baseLevel)) + { + data->baseLevel = static_cast<int>(baseLevel); + dirty = true; + } + + // Some metadata is needed only for integer textures. We avoid updating the constant buffer + // unnecessarily by changing the data only in case the texture is an integer texture and + // the values have changed. + bool needIntegerTextureMetadata = false; + // internalFormatBits == 0 means a 32-bit texture in the case of integer textures. + int internalFormatBits = 0; + switch (sizedFormat) + { + case GL_RGBA32I: + case GL_RGBA32UI: + case GL_RGB32I: + case GL_RGB32UI: + case GL_RG32I: + case GL_RG32UI: + case GL_R32I: + case GL_R32UI: + needIntegerTextureMetadata = true; + break; + case GL_RGBA16I: + case GL_RGBA16UI: + case GL_RGB16I: + case GL_RGB16UI: + case GL_RG16I: + case GL_RG16UI: + case GL_R16I: + case GL_R16UI: + needIntegerTextureMetadata = true; + internalFormatBits = 16; + break; + case GL_RGBA8I: + case GL_RGBA8UI: + case GL_RGB8I: + case GL_RGB8UI: + case GL_RG8I: + case GL_RG8UI: + case GL_R8I: + case GL_R8UI: + needIntegerTextureMetadata = true; + internalFormatBits = 8; + break; + case GL_RGB10_A2UI: + needIntegerTextureMetadata = true; + internalFormatBits = 10; + break; + default: + break; + } + if (needIntegerTextureMetadata) + { + if (data->internalFormatBits != internalFormatBits) + { + data->internalFormatBits = internalFormatBits; + dirty = true; + } + // Pack the wrap values into one integer so we can fit all the metadata in two 4-integer + // vectors. + GLenum wrapS = samplerState.getWrapS(); + GLenum wrapT = samplerState.getWrapT(); + GLenum wrapR = samplerState.getWrapR(); + int wrapModes = GetWrapBits(wrapS) | (GetWrapBits(wrapT) << 2) | (GetWrapBits(wrapR) << 4); + if (data->wrapModes != wrapModes) + { + data->wrapModes = wrapModes; + dirty = true; + } + + const angle::ColorGeneric &borderColor(samplerState.getBorderColor()); + constexpr int kBlack[4] = {}; + const void *const intBorderColor = (borderColor.type == angle::ColorGeneric::Type::Float) + ? kBlack + : borderColor.colorI.data(); + ASSERT(static_cast<const void *>(borderColor.colorI.data()) == + static_cast<const void *>(borderColor.colorUI.data())); + if (memcmp(data->intBorderColor, intBorderColor, sizeof(data->intBorderColor)) != 0) + { + memcpy(data->intBorderColor, intBorderColor, sizeof(data->intBorderColor)); + dirty = true; + } + } + + return dirty; +} + +bool ShaderConstants11::updateImageMetadata(ImageMetadata *data, const gl::ImageUnit &imageUnit) +{ + bool dirty = false; + + if (data->layer != static_cast<int>(imageUnit.layer)) + { + data->layer = static_cast<int>(imageUnit.layer); + dirty = true; + } + + if (data->level != static_cast<unsigned int>(imageUnit.level)) + { + data->level = static_cast<unsigned int>(imageUnit.level); + dirty = true; + } + + return dirty; +} + +void ShaderConstants11::setComputeWorkGroups(GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) +{ + mCompute.numWorkGroups[0] = numGroupsX; + mCompute.numWorkGroups[1] = numGroupsY; + mCompute.numWorkGroups[2] = numGroupsZ; + mShaderConstantsDirty.set(gl::ShaderType::Compute); +} + +void ShaderConstants11::setMultiviewWriteToViewportIndex(GLfloat index) +{ + mVertex.multiviewWriteToViewportIndex = index; + mPixel.multiviewWriteToViewportIndex = index; + mShaderConstantsDirty.set(gl::ShaderType::Vertex); + mShaderConstantsDirty.set(gl::ShaderType::Fragment); +} + +void ShaderConstants11::onViewportChange(const gl::Rectangle &glViewport, + const D3D11_VIEWPORT &dxViewport, + const gl::Offset &glFragCoordOffset, + bool is9_3, + bool presentPathFast) +{ + mShaderConstantsDirty.set(gl::ShaderType::Vertex); + mShaderConstantsDirty.set(gl::ShaderType::Fragment); + + // On Feature Level 9_*, we must emulate large and/or negative viewports in the shaders + // using viewAdjust (like the D3D9 renderer). + if (is9_3) + { + mVertex.viewAdjust[0] = static_cast<float>((glViewport.width - dxViewport.Width) + + 2 * (glViewport.x - dxViewport.TopLeftX)) / + dxViewport.Width; + mVertex.viewAdjust[1] = static_cast<float>((glViewport.height - dxViewport.Height) + + 2 * (glViewport.y - dxViewport.TopLeftY)) / + dxViewport.Height; + mVertex.viewAdjust[2] = static_cast<float>(glViewport.width) / dxViewport.Width; + mVertex.viewAdjust[3] = static_cast<float>(glViewport.height) / dxViewport.Height; + } + + mPixel.viewCoords[0] = glViewport.width * 0.5f; + mPixel.viewCoords[1] = glViewport.height * 0.5f; + mPixel.viewCoords[2] = glViewport.x + (glViewport.width * 0.5f); + mPixel.viewCoords[3] = glViewport.y + (glViewport.height * 0.5f); + + // Instanced pointsprite emulation requires ViewCoords to be defined in the + // the vertex shader. + mVertex.viewCoords[0] = mPixel.viewCoords[0]; + mVertex.viewCoords[1] = mPixel.viewCoords[1]; + mVertex.viewCoords[2] = mPixel.viewCoords[2]; + mVertex.viewCoords[3] = mPixel.viewCoords[3]; + + const float zNear = dxViewport.MinDepth; + const float zFar = dxViewport.MaxDepth; + + mPixel.depthFront[0] = (zFar - zNear) * 0.5f; + mPixel.depthFront[1] = (zNear + zFar) * 0.5f; + + mVertex.depthRange[0] = zNear; + mVertex.depthRange[1] = zFar; + mVertex.depthRange[2] = zFar - zNear; + + mPixel.depthRange[0] = zNear; + mPixel.depthRange[1] = zFar; + mPixel.depthRange[2] = zFar - zNear; + + mPixel.viewScale[0] = 1.0f; + mPixel.viewScale[1] = presentPathFast ? 1.0f : -1.0f; + // Updates to the multiviewWriteToViewportIndex member are to be handled whenever the draw + // framebuffer's layout is changed. + + mVertex.viewScale[0] = mPixel.viewScale[0]; + mVertex.viewScale[1] = mPixel.viewScale[1]; + + mPixel.fragCoordOffset[0] = static_cast<float>(glFragCoordOffset.x); + mPixel.fragCoordOffset[1] = static_cast<float>(glFragCoordOffset.y); +} + +// Update the ShaderConstants with a new first vertex and return whether the update dirties them. +ANGLE_INLINE bool ShaderConstants11::onFirstVertexChange(GLint firstVertex) +{ + // firstVertex should already include baseVertex, if any. + uint32_t newFirstVertex = static_cast<uint32_t>(firstVertex); + + bool firstVertexDirty = (mVertex.firstVertex != newFirstVertex); + if (firstVertexDirty) + { + mVertex.firstVertex = newFirstVertex; + mShaderConstantsDirty.set(gl::ShaderType::Vertex); + } + return firstVertexDirty; +} + +void ShaderConstants11::onSamplerChange(gl::ShaderType shaderType, + unsigned int samplerIndex, + const gl::Texture &texture, + const gl::SamplerState &samplerState) +{ + ASSERT(shaderType != gl::ShaderType::InvalidEnum); + if (updateSamplerMetadata(&mShaderSamplerMetadata[shaderType][samplerIndex], texture, + samplerState)) + { + mNumActiveShaderSamplers[shaderType] = 0; + } +} + +bool ShaderConstants11::onImageChange(gl::ShaderType shaderType, + unsigned int imageIndex, + const gl::ImageUnit &imageUnit) +{ + ASSERT(shaderType != gl::ShaderType::InvalidEnum); + bool dirty = false; + if (imageUnit.access == GL_READ_ONLY) + { + if (updateImageMetadata(&mShaderReadonlyImageMetadata[shaderType][imageIndex], imageUnit)) + { + mNumActiveShaderReadonlyImages[shaderType] = 0; + dirty = true; + } + } + else + { + if (updateImageMetadata(&mShaderImageMetadata[shaderType][imageIndex], imageUnit)) + { + mNumActiveShaderImages[shaderType] = 0; + dirty = true; + } + } + return dirty; +} + +void ShaderConstants11::onClipControlChange(bool lowerLeft, bool zeroToOne) +{ + mVertex.clipControlOrigin = lowerLeft ? -1.0f : 1.0f; + mVertex.clipControlZeroToOne = zeroToOne ? 1.0f : 0.0f; + mShaderConstantsDirty.set(gl::ShaderType::Vertex); +} + +angle::Result ShaderConstants11::updateBuffer(const gl::Context *context, + Renderer11 *renderer, + gl::ShaderType shaderType, + const ProgramD3D &programD3D, + const d3d11::Buffer &driverConstantBuffer) +{ + // Re-upload the sampler meta-data if the current program uses more samplers + // than we previously uploaded. + const int numSamplers = programD3D.getUsedSamplerRange(shaderType).length(); + const int numReadonlyImages = programD3D.getUsedImageRange(shaderType, true).length(); + const int numImages = programD3D.getUsedImageRange(shaderType, false).length(); + + const bool dirty = mShaderConstantsDirty[shaderType] || + (mNumActiveShaderSamplers[shaderType] < numSamplers) || + (mNumActiveShaderReadonlyImages[shaderType] < numReadonlyImages) || + (mNumActiveShaderImages[shaderType] < numImages); + + const size_t dataSize = GetShaderConstantsStructSize(shaderType); + const uint8_t *samplerData = + reinterpret_cast<const uint8_t *>(mShaderSamplerMetadata[shaderType].data()); + const size_t samplerDataSize = sizeof(SamplerMetadata) * numSamplers; + const uint8_t *readonlyImageData = + reinterpret_cast<const uint8_t *>(mShaderReadonlyImageMetadata[shaderType].data()); + const size_t readonlyImageDataSize = sizeof(ImageMetadata) * numReadonlyImages; + const uint8_t *imageData = + reinterpret_cast<const uint8_t *>(mShaderImageMetadata[shaderType].data()); + const size_t imageDataSize = sizeof(ImageMetadata) * numImages; + + mNumActiveShaderSamplers[shaderType] = numSamplers; + mNumActiveShaderReadonlyImages[shaderType] = numReadonlyImages; + mNumActiveShaderImages[shaderType] = numImages; + mShaderConstantsDirty.set(shaderType, false); + + const uint8_t *data = nullptr; + switch (shaderType) + { + case gl::ShaderType::Vertex: + data = reinterpret_cast<const uint8_t *>(&mVertex); + break; + case gl::ShaderType::Fragment: + data = reinterpret_cast<const uint8_t *>(&mPixel); + break; + case gl::ShaderType::Compute: + data = reinterpret_cast<const uint8_t *>(&mCompute); + break; + default: + UNREACHABLE(); + break; + } + + ASSERT(driverConstantBuffer.valid()); + + if (!dirty) + { + return angle::Result::Continue; + } + + // Previous buffer contents are discarded, so we need to refresh the whole buffer. + D3D11_MAPPED_SUBRESOURCE mapping = {}; + ANGLE_TRY(renderer->mapResource(context, driverConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, + 0, &mapping)); + + memcpy(mapping.pData, data, dataSize); + memcpy(static_cast<uint8_t *>(mapping.pData) + dataSize, samplerData, + sizeof(SamplerMetadata) * numSamplers); + + memcpy(static_cast<uint8_t *>(mapping.pData) + dataSize + samplerDataSize, readonlyImageData, + readonlyImageDataSize); + memcpy( + static_cast<uint8_t *>(mapping.pData) + dataSize + samplerDataSize + readonlyImageDataSize, + imageData, imageDataSize); + renderer->getDeviceContext()->Unmap(driverConstantBuffer.get(), 0); + + return angle::Result::Continue; +} + +StateManager11::StateManager11(Renderer11 *renderer) + : mRenderer(renderer), + mInternalDirtyBits(), + mCurSampleAlphaToCoverage(false), + mCurBlendStateExt(), + mCurBlendColor(0, 0, 0, 0), + mCurSampleMask(0), + mCurStencilRef(0), + mCurStencilBackRef(0), + mCurStencilSize(0), + mCurScissorEnabled(false), + mCurScissorRect(), + mCurViewport(), + mCurNear(0.0f), + mCurFar(0.0f), + mViewportBounds(), + mRenderTargetIsDirty(true), + mCurPresentPathFastEnabled(false), + mCurPresentPathFastColorBufferHeight(0), + mDirtyCurrentValueAttribs(), + mCurrentValueAttribs(), + mCurrentInputLayout(), + mDirtyVertexBufferRange(gl::MAX_VERTEX_ATTRIBS, 0), + mCurrentPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_UNDEFINED), + mLastAppliedDrawMode(gl::PrimitiveMode::InvalidEnum), + mCullEverything(false), + mDirtySwizzles(false), + mAppliedIB(nullptr), + mAppliedIBFormat(DXGI_FORMAT_UNKNOWN), + mAppliedIBOffset(0), + mIndexBufferIsDirty(false), + mVertexDataManager(renderer), + mIndexDataManager(renderer), + mIsMultiviewEnabled(false), + mIndependentBlendStates(false), + mEmptySerial(mRenderer->generateSerial()), + mProgramD3D(nullptr), + mVertexArray11(nullptr), + mFramebuffer11(nullptr) +{ + mCurDepthStencilState.depthTest = false; + mCurDepthStencilState.depthFunc = GL_LESS; + mCurDepthStencilState.depthMask = true; + mCurDepthStencilState.stencilTest = false; + mCurDepthStencilState.stencilMask = true; + mCurDepthStencilState.stencilFail = GL_KEEP; + mCurDepthStencilState.stencilPassDepthFail = GL_KEEP; + mCurDepthStencilState.stencilPassDepthPass = GL_KEEP; + mCurDepthStencilState.stencilWritemask = static_cast<GLuint>(-1); + mCurDepthStencilState.stencilBackFunc = GL_ALWAYS; + mCurDepthStencilState.stencilBackMask = static_cast<GLuint>(-1); + mCurDepthStencilState.stencilBackFail = GL_KEEP; + mCurDepthStencilState.stencilBackPassDepthFail = GL_KEEP; + mCurDepthStencilState.stencilBackPassDepthPass = GL_KEEP; + mCurDepthStencilState.stencilBackWritemask = static_cast<GLuint>(-1); + + mCurRasterState.rasterizerDiscard = false; + mCurRasterState.cullFace = false; + mCurRasterState.cullMode = gl::CullFaceMode::Back; + mCurRasterState.frontFace = GL_CCW; + mCurRasterState.polygonOffsetFill = false; + mCurRasterState.polygonOffsetFactor = 0.0f; + mCurRasterState.polygonOffsetUnits = 0.0f; + mCurRasterState.pointDrawMode = false; + mCurRasterState.multiSample = false; + mCurRasterState.dither = false; + + // Start with all internal dirty bits set except the SRV and UAV bits. + mInternalDirtyBits.set(); + mInternalDirtyBits.reset(DIRTY_BIT_GRAPHICS_SRV_STATE); + mInternalDirtyBits.reset(DIRTY_BIT_GRAPHICS_UAV_STATE); + mInternalDirtyBits.reset(DIRTY_BIT_COMPUTE_SRV_STATE); + mInternalDirtyBits.reset(DIRTY_BIT_COMPUTE_UAV_STATE); + + mGraphicsDirtyBitsMask.set(); + mGraphicsDirtyBitsMask.reset(DIRTY_BIT_COMPUTE_SRV_STATE); + mGraphicsDirtyBitsMask.reset(DIRTY_BIT_COMPUTE_UAV_STATE); + mComputeDirtyBitsMask.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); + mComputeDirtyBitsMask.set(DIRTY_BIT_PROGRAM_UNIFORMS); + mComputeDirtyBitsMask.set(DIRTY_BIT_DRIVER_UNIFORMS); + mComputeDirtyBitsMask.set(DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS); + mComputeDirtyBitsMask.set(DIRTY_BIT_SHADERS); + mComputeDirtyBitsMask.set(DIRTY_BIT_COMPUTE_SRV_STATE); + mComputeDirtyBitsMask.set(DIRTY_BIT_COMPUTE_UAV_STATE); + + // Initially all current value attributes must be updated on first use. + mDirtyCurrentValueAttribs.set(); + + mCurrentVertexBuffers.fill(nullptr); + mCurrentVertexStrides.fill(std::numeric_limits<UINT>::max()); + mCurrentVertexOffsets.fill(std::numeric_limits<UINT>::max()); +} + +StateManager11::~StateManager11() {} + +template <typename SRVType> +void StateManager11::setShaderResourceInternal(gl::ShaderType shaderType, + UINT resourceSlot, + const SRVType *srv) +{ + auto *currentSRVs = getSRVCache(shaderType); + ASSERT(static_cast<size_t>(resourceSlot) < currentSRVs->size()); + const ViewRecord<D3D11_SHADER_RESOURCE_VIEW_DESC> &record = (*currentSRVs)[resourceSlot]; + + if (record.view != reinterpret_cast<uintptr_t>(srv)) + { + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + ID3D11ShaderResourceView *srvPtr = srv ? srv->get() : nullptr; + if (srvPtr) + { + uintptr_t resource = reinterpret_cast<uintptr_t>(GetViewResource(srvPtr)); + unsetConflictingUAVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Compute, + resource, nullptr); + } + + switch (shaderType) + { + case gl::ShaderType::Vertex: + deviceContext->VSSetShaderResources(resourceSlot, 1, &srvPtr); + break; + case gl::ShaderType::Fragment: + deviceContext->PSSetShaderResources(resourceSlot, 1, &srvPtr); + break; + case gl::ShaderType::Compute: + { + if (srvPtr) + { + uintptr_t resource = reinterpret_cast<uintptr_t>(GetViewResource(srvPtr)); + unsetConflictingRTVs(resource); + } + deviceContext->CSSetShaderResources(resourceSlot, 1, &srvPtr); + break; + } + default: + UNREACHABLE(); + } + + currentSRVs->update(resourceSlot, srvPtr); + } +} + +template <typename UAVType> +void StateManager11::setUnorderedAccessViewInternal(UINT resourceSlot, + const UAVType *uav, + UAVList *uavList) +{ + ASSERT(static_cast<size_t>(resourceSlot) < mCurComputeUAVs.size()); + const ViewRecord<D3D11_UNORDERED_ACCESS_VIEW_DESC> &record = mCurComputeUAVs[resourceSlot]; + + if (record.view != reinterpret_cast<uintptr_t>(uav)) + { + ID3D11UnorderedAccessView *uavPtr = uav ? uav->get() : nullptr; + // We need to make sure that resource being set to UnorderedAccessView slot |resourceSlot| + // is not bound on SRV. + if (uavPtr) + { + uintptr_t resource = reinterpret_cast<uintptr_t>(GetViewResource(uavPtr)); + unsetConflictingSRVs(gl::PipelineType::ComputePipeline, gl::ShaderType::Vertex, + resource, nullptr, false); + unsetConflictingSRVs(gl::PipelineType::ComputePipeline, gl::ShaderType::Fragment, + resource, nullptr, false); + unsetConflictingSRVs(gl::PipelineType::ComputePipeline, gl::ShaderType::Compute, + resource, nullptr, false); + } + uavList->data[resourceSlot] = uavPtr; + if (static_cast<int>(resourceSlot) > uavList->highestUsed) + { + uavList->highestUsed = resourceSlot; + } + + mCurComputeUAVs.update(resourceSlot, uavPtr); + } +} + +void StateManager11::updateStencilSizeIfChanged(bool depthStencilInitialized, + unsigned int stencilSize) +{ + if (!depthStencilInitialized || stencilSize != mCurStencilSize) + { + mCurStencilSize = stencilSize; + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + } +} + +void StateManager11::checkPresentPath(const gl::Context *context) +{ + const auto *framebuffer = context->getState().getDrawFramebuffer(); + const auto *firstColorAttachment = framebuffer->getFirstColorAttachment(); + const bool clipSpaceOriginUpperLeft = + context->getState().getClipSpaceOrigin() == gl::ClipSpaceOrigin::UpperLeft; + const bool presentPathFastActive = + UsePresentPathFast(mRenderer, firstColorAttachment) || clipSpaceOriginUpperLeft; + + const int colorBufferHeight = firstColorAttachment ? firstColorAttachment->getSize().height : 0; + + if ((mCurPresentPathFastEnabled != presentPathFastActive) || + (presentPathFastActive && (colorBufferHeight != mCurPresentPathFastColorBufferHeight))) + { + mCurPresentPathFastEnabled = presentPathFastActive; + mCurPresentPathFastColorBufferHeight = colorBufferHeight; + + // Scissor rect may need to be vertically inverted + mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE); + + // Cull Mode may need to be inverted + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + + // Viewport may need to be vertically inverted + invalidateViewport(context); + } +} + +angle::Result StateManager11::updateStateForCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) +{ + mShaderConstants.setComputeWorkGroups(numGroupsX, numGroupsY, numGroupsZ); + + if (mProgramD3D->updateSamplerMapping() == ProgramD3D::SamplerMapping::WasDirty) + { + invalidateTexturesAndSamplers(); + } + + if (mDirtySwizzles) + { + ANGLE_TRY(generateSwizzlesForShader(context, gl::ShaderType::Compute)); + mDirtySwizzles = false; + } + + if (mProgramD3D->anyShaderUniformsDirty()) + { + mInternalDirtyBits.set(DIRTY_BIT_PROGRAM_UNIFORMS); + } + + auto dirtyBitsCopy = mInternalDirtyBits & mComputeDirtyBitsMask; + mInternalDirtyBits &= ~mComputeDirtyBitsMask; + + for (auto iter = dirtyBitsCopy.begin(), end = dirtyBitsCopy.end(); iter != end; ++iter) + { + switch (*iter) + { + case DIRTY_BIT_COMPUTE_SRV_STATE: + // Avoid to call syncTexturesForCompute function two times. + iter.resetLaterBit(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); + ANGLE_TRY(syncTexturesForCompute(context)); + break; + case DIRTY_BIT_COMPUTE_UAV_STATE: + ANGLE_TRY(syncUAVsForCompute(context)); + break; + case DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE: + ANGLE_TRY(syncTexturesForCompute(context)); + break; + case DIRTY_BIT_PROGRAM_UNIFORMS: + case DIRTY_BIT_DRIVER_UNIFORMS: + ANGLE_TRY(applyComputeUniforms(context, mProgramD3D)); + break; + case DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS: + ANGLE_TRY(syncUniformBuffers(context)); + break; + case DIRTY_BIT_SHADERS: + ANGLE_TRY(syncProgramForCompute(context)); + break; + default: + UNREACHABLE(); + break; + } + } + + return angle::Result::Continue; +} + +void StateManager11::syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + gl::Command command) +{ + if (!dirtyBits.any()) + { + return; + } + + const gl::State &state = context->getState(); + + for (size_t dirtyBit : dirtyBits) + { + switch (dirtyBit) + { + case gl::State::DIRTY_BIT_BLEND_EQUATIONS: + { + const gl::BlendStateExt &blendStateExt = state.getBlendStateExt(); + ASSERT(mCurBlendStateExt.getDrawBufferCount() == + blendStateExt.getDrawBufferCount()); + // Compare blend equations only for buffers with blending enabled because + // subsequent sync stages enforce default values for buffers with blending disabled. + if ((blendStateExt.getEnabledMask() & + mCurBlendStateExt.compareEquations(blendStateExt)) + .any()) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + } + case gl::State::DIRTY_BIT_BLEND_FUNCS: + { + const gl::BlendStateExt &blendStateExt = state.getBlendStateExt(); + ASSERT(mCurBlendStateExt.getDrawBufferCount() == + blendStateExt.getDrawBufferCount()); + // Compare blend factors only for buffers with blending enabled because + // subsequent sync stages enforce default values for buffers with blending disabled. + if ((blendStateExt.getEnabledMask() & + mCurBlendStateExt.compareFactors(blendStateExt)) + .any()) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + } + case gl::State::DIRTY_BIT_BLEND_ENABLED: + { + if (state.getBlendStateExt().getEnabledMask() != mCurBlendStateExt.getEnabledMask()) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + } + case gl::State::DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED: + if (state.isSampleAlphaToCoverageEnabled() != mCurSampleAlphaToCoverage) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + case gl::State::DIRTY_BIT_DITHER_ENABLED: + if (state.getRasterizerState().dither != mCurRasterState.dither) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + } + break; + case gl::State::DIRTY_BIT_COLOR_MASK: + { + if (state.getBlendStateExt().getColorMaskBits() != + mCurBlendStateExt.getColorMaskBits()) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + } + case gl::State::DIRTY_BIT_BLEND_COLOR: + if (state.getBlendColor() != mCurBlendColor) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + break; + // Depth and stencil redundant state changes are guarded in the + // frontend so for related cases here just set the dirty bit. + case gl::State::DIRTY_BIT_DEPTH_MASK: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_DEPTH_FUNC: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + case gl::State::DIRTY_BIT_STENCIL_OPS_BACK: + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + break; + + case gl::State::DIRTY_BIT_CULL_FACE_ENABLED: + if (state.getRasterizerState().cullFace != mCurRasterState.cullFace) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + } + break; + case gl::State::DIRTY_BIT_CULL_FACE: + if (state.getRasterizerState().cullMode != mCurRasterState.cullMode) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + } + break; + case gl::State::DIRTY_BIT_FRONT_FACE: + if (state.getRasterizerState().frontFace != mCurRasterState.frontFace) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + } + break; + case gl::State::DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED: + if (state.getRasterizerState().polygonOffsetFill != + mCurRasterState.polygonOffsetFill) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + } + break; + case gl::State::DIRTY_BIT_POLYGON_OFFSET: + { + const gl::RasterizerState &rasterState = state.getRasterizerState(); + if (rasterState.polygonOffsetFactor != mCurRasterState.polygonOffsetFactor || + rasterState.polygonOffsetUnits != mCurRasterState.polygonOffsetUnits) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + } + break; + } + case gl::State::DIRTY_BIT_RASTERIZER_DISCARD_ENABLED: + if (state.getRasterizerState().rasterizerDiscard != + mCurRasterState.rasterizerDiscard) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + + // Enabling/disabling rasterizer discard affects the pixel shader. + invalidateShaders(); + } + break; + case gl::State::DIRTY_BIT_SCISSOR: + if (state.getScissor() != mCurScissorRect) + { + mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE); + } + break; + case gl::State::DIRTY_BIT_SCISSOR_TEST_ENABLED: + if (state.isScissorTestEnabled() != mCurScissorEnabled) + { + mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE); + // Rasterizer state update needs mCurScissorsEnabled and updates when it changes + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + } + break; + case gl::State::DIRTY_BIT_DEPTH_RANGE: + invalidateViewport(context); + break; + case gl::State::DIRTY_BIT_VIEWPORT: + if (state.getViewport() != mCurViewport) + { + invalidateViewport(context); + } + break; + case gl::State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING: + invalidateRenderTarget(); + if (mIsMultiviewEnabled) + { + handleMultiviewDrawFramebufferChange(context); + } + mFramebuffer11 = GetImplAs<Framebuffer11>(state.getDrawFramebuffer()); + break; + case gl::State::DIRTY_BIT_VERTEX_ARRAY_BINDING: + invalidateVertexBuffer(); + // Force invalidate the current value attributes, since the VertexArray11 keeps an + // internal cache of TranslatedAttributes, and they CurrentValue attributes are + // owned by the StateManager11/Context. + mDirtyCurrentValueAttribs.set(); + // Invalidate the cached index buffer. + invalidateIndexBuffer(); + mVertexArray11 = GetImplAs<VertexArray11>(state.getVertexArray()); + break; + case gl::State::DIRTY_BIT_UNIFORM_BUFFER_BINDINGS: + invalidateProgramUniformBuffers(); + break; + case gl::State::DIRTY_BIT_ATOMIC_COUNTER_BUFFER_BINDING: + invalidateProgramAtomicCounterBuffers(); + break; + case gl::State::DIRTY_BIT_SHADER_STORAGE_BUFFER_BINDING: + invalidateProgramShaderStorageBuffers(); + break; + case gl::State::DIRTY_BIT_TEXTURE_BINDINGS: + invalidateTexturesAndSamplers(); + break; + case gl::State::DIRTY_BIT_SAMPLER_BINDINGS: + invalidateTexturesAndSamplers(); + break; + case gl::State::DIRTY_BIT_IMAGE_BINDINGS: + invalidateImageBindings(); + break; + case gl::State::DIRTY_BIT_TRANSFORM_FEEDBACK_BINDING: + invalidateTransformFeedback(); + break; + case gl::State::DIRTY_BIT_PROGRAM_BINDING: + mProgramD3D = GetImplAs<ProgramD3D>(state.getProgram()); + break; + case gl::State::DIRTY_BIT_PROGRAM_EXECUTABLE: + { + invalidateShaders(); + invalidateTexturesAndSamplers(); + invalidateProgramUniforms(); + invalidateProgramUniformBuffers(); + invalidateProgramAtomicCounterBuffers(); + invalidateProgramShaderStorageBuffers(); + invalidateDriverUniforms(); + const gl::ProgramExecutable *executable = state.getProgramExecutable(); + if (!executable || command != gl::Command::Dispatch) + { + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + invalidateVertexBuffer(); + invalidateRenderTarget(); + // If OVR_multiview2 is enabled, the attribute divisor has to be updated for + // each binding. When using compute, there could be no vertex array. + if (mIsMultiviewEnabled && mVertexArray11) + { + ASSERT(mProgramD3D); + ASSERT(mVertexArray11 == GetImplAs<VertexArray11>(state.getVertexArray())); + const gl::ProgramState &programState = mProgramD3D->getState(); + int numViews = + programState.usesMultiview() ? programState.getNumViews() : 1; + mVertexArray11->markAllAttributeDivisorsForAdjustment(numViews); + } + } + break; + } + case gl::State::DIRTY_BIT_CURRENT_VALUES: + { + for (auto attribIndex : state.getAndResetDirtyCurrentValues()) + { + invalidateCurrentValueAttrib(attribIndex); + } + break; + } + case gl::State::DIRTY_BIT_PROVOKING_VERTEX: + invalidateShaders(); + break; + case gl::State::DIRTY_BIT_EXTENDED: + { + gl::State::ExtendedDirtyBits extendedDirtyBits = + state.getAndResetExtendedDirtyBits(); + + for (size_t extendedDirtyBit : extendedDirtyBits) + { + switch (extendedDirtyBit) + { + case gl::State::EXTENDED_DIRTY_BIT_CLIP_CONTROL: + checkPresentPath(context); + break; + } + } + break; + } + default: + break; + } + } + + // TODO(jmadill): Input layout and vertex buffer state. +} + +void StateManager11::handleMultiviewDrawFramebufferChange(const gl::Context *context) +{ + const auto &glState = context->getState(); + const gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer(); + ASSERT(drawFramebuffer != nullptr); + + if (drawFramebuffer->isMultiview()) + { + // Because the base view index is applied as an offset to the 2D texture array when the + // RTV is created, we just have to pass a boolean to select which code path is to be + // used. + mShaderConstants.setMultiviewWriteToViewportIndex(0.0f); + } +} + +angle::Result StateManager11::syncBlendState(const gl::Context *context, + const gl::BlendStateExt &blendStateExt, + const gl::ColorF &blendColor, + unsigned int sampleMask, + bool sampleAlphaToCoverage, + bool emulateConstantAlpha) +{ + const d3d11::BlendState *dxBlendState = nullptr; + const d3d11::BlendStateKey &key = RenderStateCache::GetBlendStateKey( + context, mFramebuffer11, blendStateExt, sampleAlphaToCoverage); + + ANGLE_TRY(mRenderer->getBlendState(context, key, &dxBlendState)); + + ASSERT(dxBlendState != nullptr); + + // D3D11 does not support CONSTANT_ALPHA as source or destination color factor, so ANGLE sets + // the factor to CONSTANT_COLOR and swizzles the color value to aaaa. For this reason, it's + // impossible to simultaneously use CONSTANT_ALPHA and CONSTANT_COLOR as source or destination + // color factors in the same blend state. This is enforced in the validation layer. + float blendColors[4] = {0.0f}; + blendColors[0] = emulateConstantAlpha ? blendColor.alpha : blendColor.red; + blendColors[1] = emulateConstantAlpha ? blendColor.alpha : blendColor.green; + blendColors[2] = emulateConstantAlpha ? blendColor.alpha : blendColor.blue; + blendColors[3] = blendColor.alpha; + + mRenderer->getDeviceContext()->OMSetBlendState(dxBlendState->get(), blendColors, sampleMask); + + mCurBlendStateExt = blendStateExt; + mCurBlendColor = blendColor; + mCurSampleMask = sampleMask; + mCurSampleAlphaToCoverage = sampleAlphaToCoverage; + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncDepthStencilState(const gl::Context *context) +{ + const gl::State &glState = context->getState(); + + mCurDepthStencilState = glState.getDepthStencilState(); + mCurStencilRef = glState.getStencilRef(); + mCurStencilBackRef = glState.getStencilBackRef(); + + // get the maximum size of the stencil ref + unsigned int maxStencil = 0; + if (mCurDepthStencilState.stencilTest && mCurStencilSize > 0) + { + maxStencil = (1 << mCurStencilSize) - 1; + } + ASSERT((mCurDepthStencilState.stencilWritemask & maxStencil) == + (mCurDepthStencilState.stencilBackWritemask & maxStencil)); + ASSERT(gl::clamp(mCurStencilRef, 0, static_cast<int>(maxStencil)) == + gl::clamp(mCurStencilBackRef, 0, static_cast<int>(maxStencil))); + ASSERT((mCurDepthStencilState.stencilMask & maxStencil) == + (mCurDepthStencilState.stencilBackMask & maxStencil)); + + gl::DepthStencilState modifiedGLState = glState.getDepthStencilState(); + + ASSERT(mCurDisableDepth.valid() && mCurDisableStencil.valid()); + + if (mCurDisableDepth.value()) + { + modifiedGLState.depthTest = false; + modifiedGLState.depthMask = false; + } + + if (mCurDisableStencil.value()) + { + modifiedGLState.stencilTest = false; + } + if (!modifiedGLState.stencilTest) + { + modifiedGLState.stencilWritemask = 0; + modifiedGLState.stencilBackWritemask = 0; + } + + // If STENCIL_TEST is disabled in glState, stencil testing and writing should be disabled. + // Verify that's true in the modifiedGLState so it is propagated to d3dState. + ASSERT(glState.getDepthStencilState().stencilTest || + (!modifiedGLState.stencilTest && modifiedGLState.stencilWritemask == 0 && + modifiedGLState.stencilBackWritemask == 0)); + + const d3d11::DepthStencilState *d3dState = nullptr; + ANGLE_TRY(mRenderer->getDepthStencilState(context, modifiedGLState, &d3dState)); + ASSERT(d3dState); + + // Max D3D11 stencil reference value is 0xFF, + // corresponding to the max 8 bits in a stencil buffer + // GL specifies we should clamp the ref value to the + // nearest bit depth when doing stencil ops + static_assert(D3D11_DEFAULT_STENCIL_READ_MASK == 0xFF, + "Unexpected value of D3D11_DEFAULT_STENCIL_READ_MASK"); + static_assert(D3D11_DEFAULT_STENCIL_WRITE_MASK == 0xFF, + "Unexpected value of D3D11_DEFAULT_STENCIL_WRITE_MASK"); + UINT dxStencilRef = static_cast<UINT>(gl::clamp(mCurStencilRef, 0, 0xFF)); + + mRenderer->getDeviceContext()->OMSetDepthStencilState(d3dState->get(), dxStencilRef); + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncRasterizerState(const gl::Context *context, + gl::PrimitiveMode mode) +{ + // TODO: Remove pointDrawMode and multiSample from gl::RasterizerState. + gl::RasterizerState rasterState = context->getState().getRasterizerState(); + rasterState.pointDrawMode = (mode == gl::PrimitiveMode::Points); + rasterState.multiSample = mCurRasterState.multiSample; + + ID3D11RasterizerState *dxRasterState = nullptr; + + if (mCurPresentPathFastEnabled) + { + gl::RasterizerState modifiedRasterState = rasterState; + + // If prseent path fast is active then we need invert the front face state. + // This ensures that both gl_FrontFacing is correct, and front/back culling + // is performed correctly. + if (modifiedRasterState.frontFace == GL_CCW) + { + modifiedRasterState.frontFace = GL_CW; + } + else + { + ASSERT(modifiedRasterState.frontFace == GL_CW); + modifiedRasterState.frontFace = GL_CCW; + } + + ANGLE_TRY(mRenderer->getRasterizerState(context, modifiedRasterState, mCurScissorEnabled, + &dxRasterState)); + } + else + { + ANGLE_TRY(mRenderer->getRasterizerState(context, rasterState, mCurScissorEnabled, + &dxRasterState)); + } + + mRenderer->getDeviceContext()->RSSetState(dxRasterState); + + mCurRasterState = rasterState; + + return angle::Result::Continue; +} + +void StateManager11::syncScissorRectangle(const gl::Context *context) +{ + const auto &glState = context->getState(); + gl::Framebuffer *framebuffer = glState.getDrawFramebuffer(); + const gl::Rectangle &scissor = glState.getScissor(); + const bool enabled = glState.isScissorTestEnabled(); + + mCurScissorOffset = framebuffer->getSurfaceTextureOffset(); + + int scissorX = scissor.x + mCurScissorOffset.x; + int scissorY = scissor.y + mCurScissorOffset.y; + + if (mCurPresentPathFastEnabled) + { + scissorY = mCurPresentPathFastColorBufferHeight - scissor.height - scissor.y; + } + + if (enabled) + { + D3D11_RECT rect; + int x = scissorX; + int y = scissorY; + rect.left = std::max(0, x); + rect.top = std::max(0, y); + rect.right = x + std::max(0, scissor.width); + rect.bottom = y + std::max(0, scissor.height); + mRenderer->getDeviceContext()->RSSetScissorRects(1, &rect); + } + + mCurScissorRect = scissor; + mCurScissorEnabled = enabled; +} + +void StateManager11::syncViewport(const gl::Context *context) +{ + const auto &glState = context->getState(); + gl::Framebuffer *framebuffer = glState.getDrawFramebuffer(); + float actualZNear = gl::clamp01(glState.getNearPlane()); + float actualZFar = gl::clamp01(glState.getFarPlane()); + + const auto &caps = context->getCaps(); + int dxMaxViewportBoundsX = caps.maxViewportWidth; + int dxMaxViewportBoundsY = caps.maxViewportHeight; + int dxMinViewportBoundsX = -dxMaxViewportBoundsX; + int dxMinViewportBoundsY = -dxMaxViewportBoundsY; + + bool is9_3 = mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3; + + if (is9_3) + { + // Feature Level 9 viewports shouldn't exceed the dimensions of the rendertarget. + dxMaxViewportBoundsX = static_cast<int>(mViewportBounds.width); + dxMaxViewportBoundsY = static_cast<int>(mViewportBounds.height); + dxMinViewportBoundsX = 0; + dxMinViewportBoundsY = 0; + } + + bool clipSpaceOriginLowerLeft = glState.getClipSpaceOrigin() == gl::ClipSpaceOrigin::LowerLeft; + mShaderConstants.onClipControlChange(clipSpaceOriginLowerLeft, + glState.isClipControlDepthZeroToOne()); + + const auto &viewport = glState.getViewport(); + + int dxViewportTopLeftX = 0; + int dxViewportTopLeftY = 0; + int dxViewportWidth = 0; + int dxViewportHeight = 0; + + mCurViewportOffset = framebuffer->getSurfaceTextureOffset(); + + dxViewportTopLeftX = + gl::clamp(viewport.x + mCurViewportOffset.x, dxMinViewportBoundsX, dxMaxViewportBoundsX); + dxViewportTopLeftY = + gl::clamp(viewport.y + mCurViewportOffset.y, dxMinViewportBoundsY, dxMaxViewportBoundsY); + dxViewportWidth = gl::clamp(viewport.width, 0, dxMaxViewportBoundsX - dxViewportTopLeftX); + dxViewportHeight = gl::clamp(viewport.height, 0, dxMaxViewportBoundsY - dxViewportTopLeftY); + + D3D11_VIEWPORT dxViewport; + dxViewport.TopLeftX = static_cast<float>(dxViewportTopLeftX); + if (mCurPresentPathFastEnabled && clipSpaceOriginLowerLeft) + { + // When present path fast is active and we're rendering to framebuffer 0, we must invert + // the viewport in Y-axis. + // NOTE: We delay the inversion until right before the call to RSSetViewports, and leave + // dxViewportTopLeftY unchanged. This allows us to calculate viewAdjust below using the + // unaltered dxViewportTopLeftY value. + dxViewport.TopLeftY = static_cast<float>(mCurPresentPathFastColorBufferHeight - + dxViewportTopLeftY - dxViewportHeight); + } + else + { + dxViewport.TopLeftY = static_cast<float>(dxViewportTopLeftY); + } + + // The es 3.1 spec section 9.2 states that, "If there are no attachments, rendering + // will be limited to a rectangle having a lower left of (0, 0) and an upper right of + // (width, height), where width and height are the framebuffer object's default width + // and height." See http://anglebug.com/1594 + // If the Framebuffer has no color attachment and the default width or height is smaller + // than the current viewport, use the smaller of the two sizes. + // If framebuffer default width or height is 0, the params should not set. + if (!framebuffer->getFirstNonNullAttachment() && + (framebuffer->getDefaultWidth() || framebuffer->getDefaultHeight())) + { + dxViewport.Width = + static_cast<GLfloat>(std::min(viewport.width, framebuffer->getDefaultWidth())); + dxViewport.Height = + static_cast<GLfloat>(std::min(viewport.height, framebuffer->getDefaultHeight())); + } + else + { + dxViewport.Width = static_cast<float>(dxViewportWidth); + dxViewport.Height = static_cast<float>(dxViewportHeight); + } + dxViewport.MinDepth = actualZNear; + dxViewport.MaxDepth = actualZFar; + + mRenderer->getDeviceContext()->RSSetViewports(1, &dxViewport); + + mCurViewport = viewport; + mCurNear = actualZNear; + mCurFar = actualZFar; + + const D3D11_VIEWPORT adjustViewport = {static_cast<FLOAT>(dxViewportTopLeftX), + static_cast<FLOAT>(dxViewportTopLeftY), + static_cast<FLOAT>(dxViewportWidth), + static_cast<FLOAT>(dxViewportHeight), + actualZNear, + actualZFar}; + mShaderConstants.onViewportChange(viewport, adjustViewport, mCurViewportOffset, is9_3, + mCurPresentPathFastEnabled); +} + +void StateManager11::invalidateRenderTarget() +{ + mRenderTargetIsDirty = true; +} + +void StateManager11::processFramebufferInvalidation(const gl::Context *context) +{ + ASSERT(mRenderTargetIsDirty); + ASSERT(context); + + mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET); + + // The pixel shader is dependent on the output layout. + invalidateShaders(); + + // The D3D11 blend state is heavily dependent on the current render target. + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + + gl::Framebuffer *fbo = context->getState().getDrawFramebuffer(); + ASSERT(fbo); + + // Dirty scissor and viewport because surface texture offset might have changed. + if (mCurViewportOffset != fbo->getSurfaceTextureOffset()) + { + mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE); + } + if (mCurScissorOffset != fbo->getSurfaceTextureOffset()) + { + mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE); + } + + // Disable the depth test/depth write if we are using a stencil-only attachment. + // This is because ANGLE emulates stencil-only with D24S8 on D3D11 - we should neither read + // nor write to the unused depth part of this emulated texture. + bool disableDepth = (!fbo->hasDepth() && fbo->hasStencil()); + + // Similarly we disable the stencil portion of the DS attachment if the app only binds depth. + bool disableStencil = (fbo->hasDepth() && !fbo->hasStencil()); + + if (!mCurDisableDepth.valid() || disableDepth != mCurDisableDepth.value() || + !mCurDisableStencil.valid() || disableStencil != mCurDisableStencil.value()) + { + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); + mCurDisableDepth = disableDepth; + mCurDisableStencil = disableStencil; + } + + bool multiSample = (fbo->getSamples(context) != 0); + if (multiSample != mCurRasterState.multiSample) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + mCurRasterState.multiSample = multiSample; + } + + checkPresentPath(context); + + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + const auto *firstAttachment = fbo->getFirstNonNullAttachment(); + if (firstAttachment) + { + const auto &size = firstAttachment->getSize(); + if (mViewportBounds.width != size.width || mViewportBounds.height != size.height) + { + mViewportBounds = gl::Extents(size.width, size.height, 1); + invalidateViewport(context); + } + } + } +} + +void StateManager11::invalidateBoundViews() +{ + for (SRVCache &curShaderSRV : mCurShaderSRVs) + { + curShaderSRV.clear(); + } + + invalidateRenderTarget(); +} + +void StateManager11::invalidateVertexBuffer() +{ + unsigned int limit = std::min<unsigned int>(mRenderer->getNativeCaps().maxVertexAttributes, + gl::MAX_VERTEX_ATTRIBS); + mDirtyVertexBufferRange = gl::RangeUI(0, limit); + invalidateInputLayout(); + invalidateShaders(); + mInternalDirtyBits.set(DIRTY_BIT_CURRENT_VALUE_ATTRIBS); +} + +void StateManager11::invalidateViewport(const gl::Context *context) +{ + mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE); + + // Viewport affects the driver constants. + invalidateDriverUniforms(); +} + +void StateManager11::invalidateTexturesAndSamplers() +{ + mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); + invalidateSwizzles(); + + // Texture state affects the driver uniforms (base level, etc). + invalidateDriverUniforms(); +} + +void StateManager11::invalidateSwizzles() +{ + mDirtySwizzles = true; +} + +void StateManager11::invalidateProgramUniforms() +{ + mInternalDirtyBits.set(DIRTY_BIT_PROGRAM_UNIFORMS); +} + +void StateManager11::invalidateDriverUniforms() +{ + mInternalDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS); +} + +void StateManager11::invalidateProgramUniformBuffers() +{ + mInternalDirtyBits.set(DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS); +} + +void StateManager11::invalidateProgramAtomicCounterBuffers() +{ + mInternalDirtyBits.set(DIRTY_BIT_GRAPHICS_UAV_STATE); + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_UAV_STATE); +} + +void StateManager11::invalidateProgramShaderStorageBuffers() +{ + mInternalDirtyBits.set(DIRTY_BIT_GRAPHICS_UAV_STATE); + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_UAV_STATE); +} + +void StateManager11::invalidateImageBindings() +{ + mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); + mInternalDirtyBits.set(DIRTY_BIT_GRAPHICS_SRV_STATE); + mInternalDirtyBits.set(DIRTY_BIT_GRAPHICS_UAV_STATE); + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_SRV_STATE); + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_UAV_STATE); +} + +void StateManager11::invalidateConstantBuffer(unsigned int slot) +{ + if (slot == d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER) + { + invalidateDriverUniforms(); + } + else if (slot == d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK) + { + invalidateProgramUniforms(); + } + else + { + invalidateProgramUniformBuffers(); + } +} + +void StateManager11::invalidateShaders() +{ + mInternalDirtyBits.set(DIRTY_BIT_SHADERS); +} + +void StateManager11::invalidateTransformFeedback() +{ + // Transform feedback affects the stream-out geometry shader. + invalidateShaders(); + mInternalDirtyBits.set(DIRTY_BIT_TRANSFORM_FEEDBACK); + // syncPrimitiveTopology checks the transform feedback state. + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); +} + +void StateManager11::invalidateInputLayout() +{ + mInternalDirtyBits.set(DIRTY_BIT_VERTEX_BUFFERS_AND_INPUT_LAYOUT); +} + +void StateManager11::invalidateIndexBuffer() +{ + mIndexBufferIsDirty = true; +} + +void StateManager11::setRenderTarget(ID3D11RenderTargetView *rtv, ID3D11DepthStencilView *dsv) +{ + if (rtv) + { + unsetConflictingView(gl::PipelineType::GraphicsPipeline, rtv, true); + } + + if (dsv) + { + unsetConflictingView(gl::PipelineType::GraphicsPipeline, dsv, true); + } + + mRenderer->getDeviceContext()->OMSetRenderTargets(1, &rtv, dsv); + mCurRTVs.clear(); + mCurRTVs.update(0, rtv); + mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET); +} + +void StateManager11::setRenderTargets(ID3D11RenderTargetView **rtvs, + UINT numRTVs, + ID3D11DepthStencilView *dsv) +{ + for (UINT rtvIndex = 0; rtvIndex < numRTVs; ++rtvIndex) + { + unsetConflictingView(gl::PipelineType::GraphicsPipeline, rtvs[rtvIndex], true); + } + + if (dsv) + { + unsetConflictingView(gl::PipelineType::GraphicsPipeline, dsv, true); + } + + mRenderer->getDeviceContext()->OMSetRenderTargets(numRTVs, (numRTVs > 0) ? rtvs : nullptr, dsv); + mCurRTVs.clear(); + for (UINT i = 0; i < numRTVs; i++) + { + mCurRTVs.update(i, rtvs[i]); + } + mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET); +} + +void StateManager11::onBeginQuery(Query11 *query) +{ + mCurrentQueries.insert(query); +} + +void StateManager11::onDeleteQueryObject(Query11 *query) +{ + mCurrentQueries.erase(query); +} + +angle::Result StateManager11::onMakeCurrent(const gl::Context *context) +{ + ANGLE_TRY(ensureInitialized(context)); + + const gl::State &state = context->getState(); + + Context11 *context11 = GetImplAs<Context11>(context); + + for (Query11 *query : mCurrentQueries) + { + ANGLE_TRY(query->pause(context11)); + } + mCurrentQueries.clear(); + + for (gl::QueryType type : angle::AllEnums<gl::QueryType>()) + { + gl::Query *query = state.getActiveQuery(type); + if (query != nullptr) + { + Query11 *query11 = GetImplAs<Query11>(query); + ANGLE_TRY(query11->resume(context11)); + mCurrentQueries.insert(query11); + } + } + + // Reset the cache objects. + mProgramD3D = nullptr; + mVertexArray11 = nullptr; + mFramebuffer11 = nullptr; + + return angle::Result::Continue; +} + +void StateManager11::unsetConflictingView(gl::PipelineType pipeline, + ID3D11View *view, + bool isRenderTarget) +{ + uintptr_t resource = reinterpret_cast<uintptr_t>(GetViewResource(view)); + + unsetConflictingSRVs(pipeline, gl::ShaderType::Vertex, resource, nullptr, isRenderTarget); + unsetConflictingSRVs(pipeline, gl::ShaderType::Fragment, resource, nullptr, isRenderTarget); + unsetConflictingSRVs(pipeline, gl::ShaderType::Compute, resource, nullptr, isRenderTarget); + unsetConflictingUAVs(pipeline, gl::ShaderType::Compute, resource, nullptr); +} + +void StateManager11::unsetConflictingSRVs(gl::PipelineType pipeline, + gl::ShaderType shaderType, + uintptr_t resource, + const gl::ImageIndex *index, + bool isRenderTarget) +{ + auto *currentSRVs = getSRVCache(shaderType); + gl::PipelineType conflictPipeline = gl::GetPipelineType(shaderType); + bool foundOne = false; + size_t count = std::min(currentSRVs->size(), currentSRVs->highestUsed()); + for (size_t resourceIndex = 0; resourceIndex < count; ++resourceIndex) + { + auto &record = (*currentSRVs)[resourceIndex]; + + if (record.view && record.resource == resource && + (!index || ImageIndexConflictsWithSRV(*index, record.desc))) + { + setShaderResourceInternal<d3d11::ShaderResourceView>( + shaderType, static_cast<UINT>(resourceIndex), nullptr); + foundOne = true; + } + } + + if (foundOne && (pipeline != conflictPipeline || isRenderTarget)) + { + switch (conflictPipeline) + { + case gl::PipelineType::GraphicsPipeline: + mInternalDirtyBits.set(DIRTY_BIT_GRAPHICS_SRV_STATE); + break; + case gl::PipelineType::ComputePipeline: + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_SRV_STATE); + break; + default: + UNREACHABLE(); + } + } +} + +void StateManager11::unsetConflictingUAVs(gl::PipelineType pipeline, + gl::ShaderType shaderType, + uintptr_t resource, + const gl::ImageIndex *index) +{ + ASSERT(shaderType == gl::ShaderType::Compute); + bool foundOne = false; + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + size_t count = std::min(mCurComputeUAVs.size(), mCurComputeUAVs.highestUsed()); + for (size_t resourceIndex = 0; resourceIndex < count; ++resourceIndex) + { + auto &record = mCurComputeUAVs[resourceIndex]; + + if (record.view && record.resource == resource && + (!index || ImageIndexConflictsWithUAV(*index, record.desc))) + { + deviceContext->CSSetUnorderedAccessViews(static_cast<UINT>(resourceIndex), 1, + &mNullUAVs[0], nullptr); + mCurComputeUAVs.update(resourceIndex, nullptr); + foundOne = true; + } + } + + if (foundOne && pipeline == gl::PipelineType::GraphicsPipeline) + { + mInternalDirtyBits.set(DIRTY_BIT_COMPUTE_UAV_STATE); + } +} + +void StateManager11::unsetConflictingRTVs(uintptr_t resource) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + size_t count = std::min(mCurRTVs.size(), mCurRTVs.highestUsed()); + for (size_t resourceIndex = 0; resourceIndex < count; ++resourceIndex) + { + auto &record = mCurRTVs[resourceIndex]; + + if (record.view && record.resource == resource) + { + deviceContext->OMSetRenderTargets(0, nullptr, nullptr); + mCurRTVs.clear(); + mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET); + return; + } + } +} + +void StateManager11::unsetConflictingAttachmentResources( + const gl::FramebufferAttachment &attachment, + ID3D11Resource *resource) +{ + // Unbind render target SRVs from the shader here to prevent D3D11 warnings. + if (attachment.type() == GL_TEXTURE) + { + uintptr_t resourcePtr = reinterpret_cast<uintptr_t>(resource); + const gl::ImageIndex &index = attachment.getTextureImageIndex(); + // The index doesn't need to be corrected for the small compressed texture workaround + // because a rendertarget is never compressed. + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Vertex, + resourcePtr, &index, false); + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Fragment, + resourcePtr, &index, false); + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Compute, + resourcePtr, &index, false); + unsetConflictingUAVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Compute, + resourcePtr, &index); + } + else if (attachment.type() == GL_FRAMEBUFFER_DEFAULT) + { + uintptr_t resourcePtr = reinterpret_cast<uintptr_t>(resource); + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Vertex, + resourcePtr, nullptr, false); + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Fragment, + resourcePtr, nullptr, false); + unsetConflictingSRVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Compute, + resourcePtr, nullptr, false); + unsetConflictingUAVs(gl::PipelineType::GraphicsPipeline, gl::ShaderType::Compute, + resourcePtr, nullptr); + } +} + +angle::Result StateManager11::ensureInitialized(const gl::Context *context) +{ + Renderer11 *renderer = GetImplAs<Context11>(context)->getRenderer(); + + const gl::Caps &caps = renderer->getNativeCaps(); + const gl::Extensions &extensions = renderer->getNativeExtensions(); + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + const GLuint maxShaderTextureImageUnits = + static_cast<GLuint>(caps.maxShaderTextureImageUnits[shaderType]); + + mCurShaderSRVs[shaderType].initialize(maxShaderTextureImageUnits); + mForceSetShaderSamplerStates[shaderType].resize(maxShaderTextureImageUnits, true); + mCurShaderSamplerStates[shaderType].resize(maxShaderTextureImageUnits); + } + mCurRTVs.initialize(caps.maxColorAttachments); + mCurComputeUAVs.initialize(caps.maxImageUnits); + + // Initialize cached NULL SRV block + mNullSRVs.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment], nullptr); + + mNullUAVs.resize(caps.maxImageUnits, nullptr); + + mCurrentValueAttribs.resize(caps.maxVertexAttributes); + + mShaderConstants.init(caps); + + mIsMultiviewEnabled = extensions.multiviewOVR || extensions.multiview2OVR; + + mIndependentBlendStates = extensions.drawBuffersIndexedAny(); // requires FL10_1 + + // FL9_3 is limited to 4; ES3.1 context on FL11_0 is limited to 7 + mCurBlendStateExt = + gl::BlendStateExt(GetImplAs<Context11>(context)->getNativeCaps().maxDrawBuffers); + + ANGLE_TRY(mVertexDataManager.initialize(context)); + + mCurrentAttributes.reserve(gl::MAX_VERTEX_ATTRIBS); + + return angle::Result::Continue; +} + +void StateManager11::deinitialize() +{ + mCurrentValueAttribs.clear(); + mInputLayoutCache.clear(); + mVertexDataManager.deinitialize(); + mIndexDataManager.deinitialize(); + + for (d3d11::Buffer &ShaderDriverConstantBuffer : mShaderDriverConstantBuffers) + { + ShaderDriverConstantBuffer.reset(); + } + + mPointSpriteVertexBuffer.reset(); + mPointSpriteIndexBuffer.reset(); +} + +// Applies the render target surface, depth stencil surface, viewport rectangle and +// scissor rectangle to the renderer +angle::Result StateManager11::syncFramebuffer(const gl::Context *context) +{ + // Check for zero-sized default framebuffer, which is a special case. + // in this case we do not wish to modify any state and just silently return false. + // this will not report any gl error but will cause the calling method to return. + if (mFramebuffer11->getState().isDefault()) + { + RenderTarget11 *firstRT = mFramebuffer11->getFirstRenderTarget(); + const gl::Extents &size = firstRT->getExtents(); + if (size.empty()) + { + return angle::Result::Continue; + } + } + + RTVArray framebufferRTVs = {{}}; + const auto &colorRTs = mFramebuffer11->getCachedColorRenderTargets(); + + size_t appliedRTIndex = 0; + bool skipInactiveRTs = mRenderer->getFeatures().mrtPerfWorkaround.enabled; + const auto &drawStates = mFramebuffer11->getState().getDrawBufferStates(); + gl::DrawBufferMask activeProgramOutputs = + mProgramD3D->getState().getExecutable().getActiveOutputVariablesMask(); + UINT maxExistingRT = 0; + const auto &colorAttachments = mFramebuffer11->getState().getColorAttachments(); + + for (size_t rtIndex = 0; rtIndex < colorRTs.size(); ++rtIndex) + { + const RenderTarget11 *renderTarget = colorRTs[rtIndex]; + + // Skip inactive rendertargets if the workaround is enabled. + if (skipInactiveRTs && + (!renderTarget || drawStates[rtIndex] == GL_NONE || !activeProgramOutputs[rtIndex])) + { + continue; + } + + if (renderTarget) + { + framebufferRTVs[appliedRTIndex] = renderTarget->getRenderTargetView().get(); + ASSERT(framebufferRTVs[appliedRTIndex]); + maxExistingRT = static_cast<UINT>(appliedRTIndex) + 1; + + // Unset conflicting texture SRVs + const gl::FramebufferAttachment &attachment = colorAttachments[rtIndex]; + ASSERT(attachment.isAttached()); + unsetConflictingAttachmentResources(attachment, renderTarget->getTexture().get()); + } + + appliedRTIndex++; + } + + // Get the depth stencil buffers + ID3D11DepthStencilView *framebufferDSV = nullptr; + const auto *depthStencilRenderTarget = mFramebuffer11->getCachedDepthStencilRenderTarget(); + if (depthStencilRenderTarget) + { + framebufferDSV = depthStencilRenderTarget->getDepthStencilView().get(); + ASSERT(framebufferDSV); + + // Unset conflicting texture SRVs + const gl::FramebufferAttachment *attachment = + mFramebuffer11->getState().getDepthOrStencilAttachment(); + ASSERT(attachment); + unsetConflictingAttachmentResources(*attachment, + depthStencilRenderTarget->getTexture().get()); + } + + ASSERT(maxExistingRT <= static_cast<UINT>(context->getCaps().maxDrawBuffers)); + + // Apply the render target and depth stencil + mRenderer->getDeviceContext()->OMSetRenderTargets(maxExistingRT, framebufferRTVs.data(), + framebufferDSV); + mCurRTVs.clear(); + for (UINT i = 0; i < maxExistingRT; i++) + { + mCurRTVs.update(i, framebufferRTVs[i]); + } + return angle::Result::Continue; +} + +void StateManager11::invalidateCurrentValueAttrib(size_t attribIndex) +{ + mDirtyCurrentValueAttribs.set(attribIndex); + mInternalDirtyBits.set(DIRTY_BIT_CURRENT_VALUE_ATTRIBS); + invalidateInputLayout(); + invalidateShaders(); +} + +angle::Result StateManager11::syncCurrentValueAttribs( + const gl::Context *context, + const std::vector<gl::VertexAttribCurrentValueData> ¤tValues) +{ + const gl::ProgramExecutable &executable = mProgramD3D->getState().getExecutable(); + const auto &activeAttribsMask = executable.getActiveAttribLocationsMask(); + const auto &dirtyActiveAttribs = (activeAttribsMask & mDirtyCurrentValueAttribs); + + if (!dirtyActiveAttribs.any()) + { + return angle::Result::Continue; + } + + const auto &vertexAttributes = mVertexArray11->getState().getVertexAttributes(); + const auto &vertexBindings = mVertexArray11->getState().getVertexBindings(); + mDirtyCurrentValueAttribs = (mDirtyCurrentValueAttribs & ~dirtyActiveAttribs); + + for (auto attribIndex : dirtyActiveAttribs) + { + if (vertexAttributes[attribIndex].enabled) + continue; + + const auto *attrib = &vertexAttributes[attribIndex]; + const auto ¤tValue = currentValues[attribIndex]; + TranslatedAttribute *currentValueAttrib = &mCurrentValueAttribs[attribIndex]; + currentValueAttrib->currentValueType = currentValue.Type; + currentValueAttrib->attribute = attrib; + currentValueAttrib->binding = &vertexBindings[attrib->bindingIndex]; + + mDirtyVertexBufferRange.extend(static_cast<unsigned int>(attribIndex)); + + ANGLE_TRY(mVertexDataManager.storeCurrentValue(context, currentValue, currentValueAttrib, + static_cast<size_t>(attribIndex))); + } + + return angle::Result::Continue; +} + +void StateManager11::setInputLayout(const d3d11::InputLayout *inputLayout) +{ + if (setInputLayoutInternal(inputLayout)) + { + invalidateInputLayout(); + } +} + +bool StateManager11::setInputLayoutInternal(const d3d11::InputLayout *inputLayout) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + if (inputLayout == nullptr) + { + if (!mCurrentInputLayout.empty()) + { + deviceContext->IASetInputLayout(nullptr); + mCurrentInputLayout.clear(); + return true; + } + } + else if (inputLayout->getSerial() != mCurrentInputLayout) + { + deviceContext->IASetInputLayout(inputLayout->get()); + mCurrentInputLayout = inputLayout->getSerial(); + return true; + } + + return false; +} + +bool StateManager11::queueVertexBufferChange(size_t bufferIndex, + ID3D11Buffer *buffer, + UINT stride, + UINT offset) +{ + if (buffer != mCurrentVertexBuffers[bufferIndex] || + stride != mCurrentVertexStrides[bufferIndex] || + offset != mCurrentVertexOffsets[bufferIndex]) + { + mDirtyVertexBufferRange.extend(static_cast<unsigned int>(bufferIndex)); + + mCurrentVertexBuffers[bufferIndex] = buffer; + mCurrentVertexStrides[bufferIndex] = stride; + mCurrentVertexOffsets[bufferIndex] = offset; + return true; + } + + return false; +} + +void StateManager11::applyVertexBufferChanges() +{ + if (mDirtyVertexBufferRange.empty()) + { + return; + } + + ASSERT(mDirtyVertexBufferRange.high() <= gl::MAX_VERTEX_ATTRIBS); + + UINT start = static_cast<UINT>(mDirtyVertexBufferRange.low()); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->IASetVertexBuffers(start, static_cast<UINT>(mDirtyVertexBufferRange.length()), + &mCurrentVertexBuffers[start], &mCurrentVertexStrides[start], + &mCurrentVertexOffsets[start]); + + mDirtyVertexBufferRange = gl::RangeUI(gl::MAX_VERTEX_ATTRIBS, 0); +} + +void StateManager11::setSingleVertexBuffer(const d3d11::Buffer *buffer, UINT stride, UINT offset) +{ + ID3D11Buffer *native = buffer ? buffer->get() : nullptr; + if (queueVertexBufferChange(0, native, stride, offset)) + { + invalidateInputLayout(); + applyVertexBufferChanges(); + } +} + +angle::Result StateManager11::updateState(const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic) +{ + const gl::State &glState = context->getState(); + + // TODO(jmadill): Use dirty bits. + if (mRenderTargetIsDirty) + { + processFramebufferInvalidation(context); + mRenderTargetIsDirty = false; + } + + // TODO(jmadill): Use dirty bits. + if (mProgramD3D->updateSamplerMapping() == ProgramD3D::SamplerMapping::WasDirty) + { + invalidateTexturesAndSamplers(); + } + + // TODO(jmadill): Use dirty bits. + if (mProgramD3D->anyShaderUniformsDirty()) + { + mInternalDirtyBits.set(DIRTY_BIT_PROGRAM_UNIFORMS); + } + + // Swizzling can cause internal state changes with blit shaders. + if (mDirtySwizzles) + { + ANGLE_TRY(generateSwizzles(context)); + mDirtySwizzles = false; + } + + ANGLE_TRY(mFramebuffer11->markAttachmentsDirty(context)); + + // TODO(jiawei.shao@intel.com): This can be recomputed only on framebuffer or multisample mask + // state changes. + RenderTarget11 *firstRT = mFramebuffer11->getFirstRenderTarget(); + int samples = (firstRT ? firstRT->getSamples() : 0); + unsigned int sampleMask = GetBlendSampleMask(glState, samples); + if (sampleMask != mCurSampleMask) + { + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); + } + + ANGLE_TRY(mVertexArray11->syncStateForDraw(context, firstVertex, vertexOrIndexCount, + indexTypeOrInvalid, indices, instanceCount, + baseVertex, baseInstance, promoteDynamic)); + + // Changes in the draw call can affect the vertex buffer translations. + if (!mLastFirstVertex.valid() || mLastFirstVertex.value() != firstVertex) + { + mLastFirstVertex = firstVertex; + invalidateInputLayout(); + } + + // The ShaderConstants only need to be updated when the program uses vertexID + if (mProgramD3D->usesVertexID()) + { + GLint firstVertexOnChange = firstVertex + baseVertex; + ASSERT(mVertexArray11); + if (mVertexArray11->hasActiveDynamicAttrib(context) && + indexTypeOrInvalid != gl::DrawElementsType::InvalidEnum) + { + // drawElements with Dynamic attribute + // the firstVertex is already including baseVertex when + // doing ComputeStartVertex + firstVertexOnChange = firstVertex; + } + + if (mShaderConstants.onFirstVertexChange(firstVertexOnChange)) + { + mInternalDirtyBits.set(DIRTY_BIT_DRIVER_UNIFORMS); + } + } + + if (indexTypeOrInvalid != gl::DrawElementsType::InvalidEnum) + { + ANGLE_TRY(applyIndexBuffer(context, vertexOrIndexCount, indexTypeOrInvalid, indices)); + } + + if (mLastAppliedDrawMode != mode) + { + mLastAppliedDrawMode = mode; + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + + bool pointDrawMode = (mode == gl::PrimitiveMode::Points); + if (pointDrawMode != mCurRasterState.pointDrawMode) + { + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); + + // Changing from points to not points (or vice-versa) affects the geometry shader. + invalidateShaders(); + } + } + + auto dirtyBitsCopy = mInternalDirtyBits & mGraphicsDirtyBitsMask; + + for (auto iter = dirtyBitsCopy.begin(), end = dirtyBitsCopy.end(); iter != end; ++iter) + { + mInternalDirtyBits.reset(*iter); + switch (*iter) + { + case DIRTY_BIT_RENDER_TARGET: + ANGLE_TRY(syncFramebuffer(context)); + break; + case DIRTY_BIT_VIEWPORT_STATE: + syncViewport(context); + break; + case DIRTY_BIT_SCISSOR_STATE: + syncScissorRectangle(context); + break; + case DIRTY_BIT_RASTERIZER_STATE: + ANGLE_TRY(syncRasterizerState(context, mode)); + break; + case DIRTY_BIT_BLEND_STATE: + ANGLE_TRY(syncBlendState( + context, glState.getBlendStateExt(), glState.getBlendColor(), sampleMask, + glState.isSampleAlphaToCoverageEnabled(), glState.hasConstantAlphaBlendFunc())); + break; + case DIRTY_BIT_DEPTH_STENCIL_STATE: + ANGLE_TRY(syncDepthStencilState(context)); + break; + case DIRTY_BIT_GRAPHICS_SRV_STATE: + ANGLE_TRY(syncTextures(context)); + break; + case DIRTY_BIT_GRAPHICS_UAV_STATE: + ANGLE_TRY(syncUAVsForGraphics(context)); + break; + case DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE: + // TODO(jmadill): More fine-grained update. + ANGLE_TRY(syncTextures(context)); + break; + case DIRTY_BIT_PROGRAM_UNIFORMS: + ANGLE_TRY(applyUniforms(context)); + break; + case DIRTY_BIT_DRIVER_UNIFORMS: + // This must happen after viewport sync; the viewport affects builtin uniforms. + ANGLE_TRY(applyDriverUniforms(context)); + break; + case DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS: + ANGLE_TRY(syncUniformBuffers(context)); + break; + case DIRTY_BIT_SHADERS: + ANGLE_TRY(syncProgram(context, mode)); + break; + case DIRTY_BIT_CURRENT_VALUE_ATTRIBS: + ANGLE_TRY(syncCurrentValueAttribs(context, glState.getVertexAttribCurrentValues())); + break; + case DIRTY_BIT_TRANSFORM_FEEDBACK: + ANGLE_TRY(syncTransformFeedbackBuffers(context)); + break; + case DIRTY_BIT_VERTEX_BUFFERS_AND_INPUT_LAYOUT: + ANGLE_TRY(syncVertexBuffersAndInputLayout(context, mode, firstVertex, + vertexOrIndexCount, indexTypeOrInvalid, + instanceCount)); + break; + case DIRTY_BIT_PRIMITIVE_TOPOLOGY: + syncPrimitiveTopology(glState, mode); + break; + default: + UNREACHABLE(); + break; + } + } + + // Check that we haven't set any dirty bits in the flushing of the dirty bits loop, except + // DIRTY_BIT_COMPUTE_SRVUAV_STATE dirty bit. + ASSERT((mInternalDirtyBits & mGraphicsDirtyBitsMask).none()); + + return angle::Result::Continue; +} + +void StateManager11::setShaderResourceShared(gl::ShaderType shaderType, + UINT resourceSlot, + const d3d11::SharedSRV *srv) +{ + setShaderResourceInternal(shaderType, resourceSlot, srv); + + // TODO(jmadill): Narrower dirty region. + mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); +} + +void StateManager11::setShaderResource(gl::ShaderType shaderType, + UINT resourceSlot, + const d3d11::ShaderResourceView *srv) +{ + setShaderResourceInternal(shaderType, resourceSlot, srv); + + // TODO(jmadill): Narrower dirty region. + mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); +} + +void StateManager11::setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology) +{ + if (setPrimitiveTopologyInternal(primitiveTopology)) + { + mInternalDirtyBits.set(DIRTY_BIT_PRIMITIVE_TOPOLOGY); + } +} + +bool StateManager11::setPrimitiveTopologyInternal(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology) +{ + if (primitiveTopology != mCurrentPrimitiveTopology) + { + mRenderer->getDeviceContext()->IASetPrimitiveTopology(primitiveTopology); + mCurrentPrimitiveTopology = primitiveTopology; + return true; + } + else + { + return false; + } +} + +void StateManager11::setDrawShaders(const d3d11::VertexShader *vertexShader, + const d3d11::GeometryShader *geometryShader, + const d3d11::PixelShader *pixelShader) +{ + setVertexShader(vertexShader); + setGeometryShader(geometryShader); + setPixelShader(pixelShader); +} + +void StateManager11::setVertexShader(const d3d11::VertexShader *shader) +{ + ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); + + if (serial != mAppliedShaders[gl::ShaderType::Vertex]) + { + ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr; + mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0); + mAppliedShaders[gl::ShaderType::Vertex] = serial; + invalidateShaders(); + } +} + +void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader) +{ + ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); + + if (serial != mAppliedShaders[gl::ShaderType::Geometry]) + { + ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr; + mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0); + mAppliedShaders[gl::ShaderType::Geometry] = serial; + invalidateShaders(); + } +} + +void StateManager11::setPixelShader(const d3d11::PixelShader *shader) +{ + ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); + + if (serial != mAppliedShaders[gl::ShaderType::Fragment]) + { + ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr; + mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0); + mAppliedShaders[gl::ShaderType::Fragment] = serial; + invalidateShaders(); + } +} + +void StateManager11::setComputeShader(const d3d11::ComputeShader *shader) +{ + ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); + + if (serial != mAppliedShaders[gl::ShaderType::Compute]) + { + ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr; + mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0); + mAppliedShaders[gl::ShaderType::Compute] = serial; + invalidateShaders(); + } +} + +void StateManager11::setVertexConstantBuffer(unsigned int slot, const d3d11::Buffer *buffer) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + auto ¤tSerial = mCurrentConstantBufferVS[slot]; + + mCurrentConstantBufferVSOffset[slot] = 0; + mCurrentConstantBufferVSSize[slot] = 0; + + if (buffer) + { + if (currentSerial != buffer->getSerial()) + { + deviceContext->VSSetConstantBuffers(slot, 1, buffer->getPointer()); + currentSerial = buffer->getSerial(); + invalidateConstantBuffer(slot); + } + } + else + { + if (!currentSerial.empty()) + { + ID3D11Buffer *nullBuffer = nullptr; + deviceContext->VSSetConstantBuffers(slot, 1, &nullBuffer); + currentSerial.clear(); + invalidateConstantBuffer(slot); + } + } +} + +void StateManager11::setPixelConstantBuffer(unsigned int slot, const d3d11::Buffer *buffer) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + auto ¤tSerial = mCurrentConstantBufferPS[slot]; + + mCurrentConstantBufferPSOffset[slot] = 0; + mCurrentConstantBufferPSSize[slot] = 0; + + if (buffer) + { + if (currentSerial != buffer->getSerial()) + { + deviceContext->PSSetConstantBuffers(slot, 1, buffer->getPointer()); + currentSerial = buffer->getSerial(); + invalidateConstantBuffer(slot); + } + } + else + { + if (!currentSerial.empty()) + { + ID3D11Buffer *nullBuffer = nullptr; + deviceContext->PSSetConstantBuffers(slot, 1, &nullBuffer); + currentSerial.clear(); + invalidateConstantBuffer(slot); + } + } +} + +void StateManager11::setDepthStencilState(const d3d11::DepthStencilState *depthStencilState, + UINT stencilRef) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + if (depthStencilState) + { + deviceContext->OMSetDepthStencilState(depthStencilState->get(), stencilRef); + } + else + { + deviceContext->OMSetDepthStencilState(nullptr, stencilRef); + } + + mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE); +} + +void StateManager11::setSimpleBlendState(const d3d11::BlendState *blendState) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + if (blendState) + { + deviceContext->OMSetBlendState(blendState->get(), nullptr, 0xFFFFFFFF); + } + else + { + deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFFF); + } + + mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE); +} + +void StateManager11::setRasterizerState(const d3d11::RasterizerState *rasterizerState) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + if (rasterizerState) + { + deviceContext->RSSetState(rasterizerState->get()); + } + else + { + deviceContext->RSSetState(nullptr); + } + + mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE); +} + +void StateManager11::setSimpleViewport(const gl::Extents &extents) +{ + setSimpleViewport(extents.width, extents.height); +} + +void StateManager11::setSimpleViewport(int width, int height) +{ + D3D11_VIEWPORT viewport; + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = static_cast<FLOAT>(width); + viewport.Height = static_cast<FLOAT>(height); + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; + + mRenderer->getDeviceContext()->RSSetViewports(1, &viewport); + mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE); +} + +void StateManager11::setSimplePixelTextureAndSampler(const d3d11::SharedSRV &srv, + const d3d11::SamplerState &samplerState) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + setShaderResourceInternal(gl::ShaderType::Fragment, 0, &srv); + deviceContext->PSSetSamplers(0, 1, samplerState.getPointer()); + + mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); + mForceSetShaderSamplerStates[gl::ShaderType::Fragment][0] = true; +} + +void StateManager11::setSimpleScissorRect(const gl::Rectangle &glRect) +{ + D3D11_RECT scissorRect; + scissorRect.left = glRect.x; + scissorRect.right = glRect.x + glRect.width; + scissorRect.top = glRect.y; + scissorRect.bottom = glRect.y + glRect.height; + setScissorRectD3D(scissorRect); +} + +void StateManager11::setScissorRectD3D(const D3D11_RECT &d3dRect) +{ + mRenderer->getDeviceContext()->RSSetScissorRects(1, &d3dRect); + mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE); +} + +angle::Result StateManager11::syncTextures(const gl::Context *context) +{ + ANGLE_TRY(applyTexturesForSRVs(context, gl::ShaderType::Vertex)); + ANGLE_TRY(applyTexturesForSRVs(context, gl::ShaderType::Fragment)); + if (mProgramD3D->hasShaderStage(gl::ShaderType::Geometry)) + { + ANGLE_TRY(applyTexturesForSRVs(context, gl::ShaderType::Geometry)); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::setSamplerState(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &samplerState) +{ +#if !defined(NDEBUG) + // Storage should exist, texture should be complete. Only verified in Debug. + TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture); + TextureStorage *storage = nullptr; + ANGLE_TRY(textureD3D->getNativeTexture(context, &storage)); + ASSERT(storage); +#endif // !defined(NDEBUG) + + auto *deviceContext = mRenderer->getDeviceContext(); + + ASSERT(index < mRenderer->getNativeCaps().maxShaderTextureImageUnits[type]); + + if (mForceSetShaderSamplerStates[type][index] || + memcmp(&samplerState, &mCurShaderSamplerStates[type][index], sizeof(gl::SamplerState)) != 0) + { + ID3D11SamplerState *dxSamplerState = nullptr; + ANGLE_TRY(mRenderer->getSamplerState(context, samplerState, &dxSamplerState)); + + ASSERT(dxSamplerState != nullptr); + + switch (type) + { + case gl::ShaderType::Vertex: + deviceContext->VSSetSamplers(index, 1, &dxSamplerState); + break; + case gl::ShaderType::Fragment: + deviceContext->PSSetSamplers(index, 1, &dxSamplerState); + break; + case gl::ShaderType::Compute: + deviceContext->CSSetSamplers(index, 1, &dxSamplerState); + break; + case gl::ShaderType::Geometry: + deviceContext->GSSetSamplers(index, 1, &dxSamplerState); + break; + default: + UNREACHABLE(); + break; + } + + mCurShaderSamplerStates[type][index] = samplerState; + } + + mForceSetShaderSamplerStates[type][index] = false; + + // Sampler metadata that's passed to shaders in uniforms is stored separately from rest of the + // sampler state since having it in contiguous memory makes it possible to memcpy to a constant + // buffer, and it doesn't affect the state set by + // PSSetSamplers/VSSetSamplers/CSSetSamplers/GSSetSamplers. + mShaderConstants.onSamplerChange(type, index, *texture, samplerState); + + return angle::Result::Continue; +} + +angle::Result StateManager11::setTextureForSampler(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &sampler) +{ + const d3d11::SharedSRV *textureSRV = nullptr; + + if (texture) + { + TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage)); + + // Texture should be complete and have a storage + ASSERT(texStorage); + + TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage); + + ANGLE_TRY( + storage11->getSRVForSampler(context, texture->getTextureState(), sampler, &textureSRV)); + + // If we get an invalid SRV here, something went wrong in the texture class and we're + // unexpectedly missing the shader resource view. + ASSERT(textureSRV->valid()); + + textureImpl->resetDirty(); + } + + ASSERT( + (type == gl::ShaderType::Fragment && + index < mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Fragment]) || + (type == gl::ShaderType::Vertex && + index < mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Vertex]) || + (type == gl::ShaderType::Compute && + index < mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Compute])); + + setShaderResourceInternal(type, index, textureSRV); + return angle::Result::Continue; +} + +angle::Result StateManager11::setImageState(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit) +{ + ASSERT(index < mRenderer->getNativeCaps().maxShaderImageUniforms[type]); + + if (mShaderConstants.onImageChange(type, index, imageUnit)) + { + invalidateProgramUniforms(); + } + + return angle::Result::Continue; +} + +// For each Direct3D sampler of either the pixel or vertex stage, +// looks up the corresponding OpenGL texture image unit and texture type, +// and sets the texture and its addressing/filtering state (or NULL when inactive). +// Sampler mapping needs to be up-to-date on the program object before this is called. +angle::Result StateManager11::applyTexturesForSRVs(const gl::Context *context, + gl::ShaderType shaderType) +{ + const auto &glState = context->getState(); + const auto &caps = context->getCaps(); + + ASSERT(!mProgramD3D->isSamplerMappingDirty()); + + // TODO(jmadill): Use the Program's sampler bindings. + const gl::ActiveTexturesCache &completeTextures = glState.getActiveTexturesCache(); + + const gl::RangeUI samplerRange = mProgramD3D->getUsedSamplerRange(shaderType); + for (unsigned int samplerIndex = samplerRange.low(); samplerIndex < samplerRange.high(); + samplerIndex++) + { + GLint textureUnit = mProgramD3D->getSamplerMapping(shaderType, samplerIndex, caps); + ASSERT(textureUnit != -1); + gl::Texture *texture = completeTextures[textureUnit]; + + // A nullptr texture indicates incomplete. + if (texture) + { + gl::Sampler *samplerObject = glState.getSampler(textureUnit); + + const gl::SamplerState &samplerState = + samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState(); + + ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, texture, samplerState)); + ANGLE_TRY( + setTextureForSampler(context, shaderType, samplerIndex, texture, samplerState)); + } + else + { + gl::TextureType textureType = + mProgramD3D->getSamplerTextureType(shaderType, samplerIndex); + + // Texture is not sampler complete or it is in use by the framebuffer. Bind the + // incomplete texture. + gl::Texture *incompleteTexture = nullptr; + ANGLE_TRY(mRenderer->getIncompleteTexture(context, textureType, &incompleteTexture)); + ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture, + incompleteTexture->getSamplerState())); + ANGLE_TRY(setTextureForSampler(context, shaderType, samplerIndex, incompleteTexture, + incompleteTexture->getSamplerState())); + } + } + + const gl::RangeUI readonlyImageRange = mProgramD3D->getUsedImageRange(shaderType, true); + for (unsigned int readonlyImageIndex = readonlyImageRange.low(); + readonlyImageIndex < readonlyImageRange.high(); readonlyImageIndex++) + { + GLint imageUnitIndex = + mProgramD3D->getImageMapping(shaderType, readonlyImageIndex, true, caps); + ASSERT(imageUnitIndex != -1); + const gl::ImageUnit &imageUnit = glState.getImageUnit(imageUnitIndex); + if (!imageUnit.layered) + { + ANGLE_TRY(setImageState(context, gl::ShaderType::Compute, + readonlyImageIndex - readonlyImageRange.low(), imageUnit)); + } + ANGLE_TRY(setTextureForImage(context, shaderType, readonlyImageIndex, imageUnit)); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::getUAVsForRWImages(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList) +{ + const auto &glState = context->getState(); + const auto &caps = context->getCaps(); + + const gl::RangeUI imageRange = mProgramD3D->getUsedImageRange(shaderType, false); + for (unsigned int imageIndex = imageRange.low(); imageIndex < imageRange.high(); imageIndex++) + { + GLint imageUnitIndex = mProgramD3D->getImageMapping(shaderType, imageIndex, false, caps); + ASSERT(imageUnitIndex != -1); + const gl::ImageUnit &imageUnit = glState.getImageUnit(imageUnitIndex); + if (!imageUnit.layered) + { + ANGLE_TRY(setImageState(context, shaderType, imageIndex - imageRange.low(), imageUnit)); + } + ANGLE_TRY(getUAVForRWImage(context, shaderType, imageIndex, imageUnit, uavList)); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncTexturesForCompute(const gl::Context *context) +{ + ANGLE_TRY(applyTexturesForSRVs(context, gl::ShaderType::Compute)); + return angle::Result::Continue; +} + +angle::Result StateManager11::setTextureForImage(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit) +{ + TextureD3D *textureImpl = nullptr; + if (!imageUnit.texture.get()) + { + setShaderResourceInternal<d3d11::ShaderResourceView>(type, static_cast<UINT>(index), + nullptr); + return angle::Result::Continue; + } + + textureImpl = GetImplAs<TextureD3D>(imageUnit.texture.get()); + + // Ensure that texture has unordered access; convert it if not. + ANGLE_TRY(textureImpl->ensureUnorderedAccess(context)); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage)); + // Texture should be complete and have a storage + ASSERT(texStorage); + TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage); + + const d3d11::SharedSRV *textureSRV = nullptr; + ANGLE_TRY(storage11->getSRVForImage(context, imageUnit, &textureSRV)); + // If we get an invalid SRV here, something went wrong in the texture class and we're + // unexpectedly missing the shader resource view. + ASSERT(textureSRV->valid()); + ASSERT((index < mRenderer->getNativeCaps().maxImageUnits)); + setShaderResourceInternal(type, index, textureSRV); + + textureImpl->resetDirty(); + return angle::Result::Continue; +} + +angle::Result StateManager11::getUAVForRWImage(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit, + UAVList *uavList) +{ + TextureD3D *textureImpl = nullptr; + if (!imageUnit.texture.get()) + { + setUnorderedAccessViewInternal<d3d11::UnorderedAccessView>(static_cast<UINT>(index), + nullptr, uavList); + return angle::Result::Continue; + } + + textureImpl = GetImplAs<TextureD3D>(imageUnit.texture.get()); + + // Ensure that texture has unordered access; convert it if not. + ANGLE_TRY(textureImpl->ensureUnorderedAccess(context)); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage)); + // Texture should be complete and have a storage + ASSERT(texStorage); + TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage); + + const d3d11::SharedUAV *textureUAV = nullptr; + ANGLE_TRY(storage11->getUAVForImage(context, imageUnit, &textureUAV)); + // If we get an invalid UAV here, something went wrong in the texture class and we're + // unexpectedly missing the unordered access view. + ASSERT(textureUAV->valid()); + ASSERT((index < mRenderer->getNativeCaps().maxImageUnits)); + setUnorderedAccessViewInternal(index, textureUAV, uavList); + + textureImpl->resetDirty(); + return angle::Result::Continue; +} + +// Things that affect a program's dirtyness: +// 1. Directly changing the program executable -> triggered in StateManager11::syncState. +// 2. The vertex attribute layout -> triggered in VertexArray11::syncState/signal. +// 3. The fragment shader's rendertargets -> triggered in Framebuffer11::syncState/signal. +// 4. Enabling/disabling rasterizer discard. -> triggered in StateManager11::syncState. +// 5. Enabling/disabling transform feedback. -> checked in StateManager11::updateState. +// 6. An internal shader was used. -> triggered in StateManager11::set*Shader. +// 7. Drawing with/without point sprites. -> checked in StateManager11::updateState. +// TODO(jmadill): Use dirty bits for transform feedback. +angle::Result StateManager11::syncProgram(const gl::Context *context, gl::PrimitiveMode drawMode) +{ + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_TRY(context11->triggerDrawCallProgramRecompilation(context, drawMode)); + + const auto &glState = context->getState(); + + mProgramD3D->updateCachedInputLayout(mVertexArray11->getCurrentStateSerial(), glState); + + // Binaries must be compiled before the sync. + ASSERT(mProgramD3D->hasVertexExecutableForCachedInputLayout()); + ASSERT(mProgramD3D->hasGeometryExecutableForPrimitiveType(glState, drawMode)); + ASSERT(mProgramD3D->hasPixelExecutableForCachedOutputLayout()); + + ShaderExecutableD3D *vertexExe = nullptr; + ANGLE_TRY(mProgramD3D->getVertexExecutableForCachedInputLayout(context11, &vertexExe, nullptr)); + + ShaderExecutableD3D *pixelExe = nullptr; + ANGLE_TRY(mProgramD3D->getPixelExecutableForCachedOutputLayout(context11, &pixelExe, nullptr)); + + ShaderExecutableD3D *geometryExe = nullptr; + ANGLE_TRY(mProgramD3D->getGeometryExecutableForPrimitiveType(context11, glState, drawMode, + &geometryExe, nullptr)); + + const d3d11::VertexShader *vertexShader = + (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr); + + // Skip pixel shader if we're doing rasterizer discard. + const d3d11::PixelShader *pixelShader = nullptr; + if (!glState.getRasterizerState().rasterizerDiscard) + { + pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr); + } + + const d3d11::GeometryShader *geometryShader = nullptr; + if (glState.isTransformFeedbackActiveUnpaused()) + { + geometryShader = + (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr); + } + else + { + geometryShader = + (geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr); + } + + setDrawShaders(vertexShader, geometryShader, pixelShader); + + // Explicitly clear the shaders dirty bit. + mInternalDirtyBits.reset(DIRTY_BIT_SHADERS); + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncProgramForCompute(const gl::Context *context) +{ + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_TRY(context11->triggerDispatchCallProgramRecompilation(context)); + + mProgramD3D->updateCachedComputeImage2DBindLayout(context); + + // Binaries must be compiled before the sync. + ASSERT(mProgramD3D->hasComputeExecutableForCachedImage2DBindLayout()); + + ShaderExecutableD3D *computeExe = nullptr; + ANGLE_TRY(mProgramD3D->getComputeExecutableForImage2DBindLayout(context, context11, &computeExe, + nullptr)); + + const d3d11::ComputeShader *computeShader = + (computeExe ? &GetAs<ShaderExecutable11>(computeExe)->getComputeShader() : nullptr); + setComputeShader(computeShader); + // Explicitly clear the shaders dirty bit. + mInternalDirtyBits.reset(DIRTY_BIT_SHADERS); + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncVertexBuffersAndInputLayout( + const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + GLsizei instanceCount) +{ + const auto &vertexArrayAttribs = mVertexArray11->getTranslatedAttribs(); + + // Sort the attributes according to ensure we re-use similar input layouts. + AttribIndexArray sortedSemanticIndices; + SortAttributesByLayout(*mProgramD3D, vertexArrayAttribs, mCurrentValueAttribs, + &sortedSemanticIndices, &mCurrentAttributes); + + D3D_FEATURE_LEVEL featureLevel = mRenderer->getRenderer11DeviceCaps().featureLevel; + + // If we are using FL 9_3, make sure the first attribute is not instanced + if (featureLevel <= D3D_FEATURE_LEVEL_9_3 && !mCurrentAttributes.empty()) + { + if (mCurrentAttributes[0]->divisor > 0) + { + Optional<size_t> firstNonInstancedIndex = FindFirstNonInstanced(mCurrentAttributes); + if (firstNonInstancedIndex.valid()) + { + size_t index = firstNonInstancedIndex.value(); + std::swap(mCurrentAttributes[0], mCurrentAttributes[index]); + std::swap(sortedSemanticIndices[0], sortedSemanticIndices[index]); + } + } + } + + // Update the applied input layout by querying the cache. + const gl::State &state = context->getState(); + const d3d11::InputLayout *inputLayout = nullptr; + ANGLE_TRY(mInputLayoutCache.getInputLayout(GetImplAs<Context11>(context), state, + mCurrentAttributes, sortedSemanticIndices, mode, + vertexOrIndexCount, instanceCount, &inputLayout)); + setInputLayoutInternal(inputLayout); + + // Update the applied vertex buffers. + ANGLE_TRY(applyVertexBuffers(context, mode, indexTypeOrInvalid, firstVertex)); + + return angle::Result::Continue; +} + +angle::Result StateManager11::applyVertexBuffers(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType indexTypeOrInvalid, + GLint firstVertex) +{ + bool programUsesInstancedPointSprites = + mProgramD3D->usesPointSize() && mProgramD3D->usesInstancedPointSpriteEmulation(); + bool instancedPointSpritesActive = + programUsesInstancedPointSprites && (mode == gl::PrimitiveMode::Points); + + // Note that if we use instance emulation, we reserve the first buffer slot. + size_t reservedBuffers = GetReservedBufferCount(programUsesInstancedPointSprites); + + for (size_t attribIndex = 0; attribIndex < (gl::MAX_VERTEX_ATTRIBS - reservedBuffers); + ++attribIndex) + { + ID3D11Buffer *buffer = nullptr; + UINT vertexStride = 0; + UINT vertexOffset = 0; + + if (attribIndex < mCurrentAttributes.size()) + { + const TranslatedAttribute &attrib = *mCurrentAttributes[attribIndex]; + Buffer11 *bufferStorage = attrib.storage ? GetAs<Buffer11>(attrib.storage) : nullptr; + + // If indexed pointsprite emulation is active, then we need to take a less efficent code + // path. Emulated indexed pointsprite rendering requires that the vertex buffers match + // exactly to the indices passed by the caller. This could expand or shrink the vertex + // buffer depending on the number of points indicated by the index list or how many + // duplicates are found on the index list. + if (bufferStorage == nullptr) + { + ASSERT(attrib.vertexBuffer.get()); + buffer = GetAs<VertexBuffer11>(attrib.vertexBuffer.get())->getBuffer().get(); + } + else if (instancedPointSpritesActive && + indexTypeOrInvalid != gl::DrawElementsType::InvalidEnum) + { + ASSERT(mVertexArray11->isCachedIndexInfoValid()); + TranslatedIndexData indexInfo = mVertexArray11->getCachedIndexInfo(); + if (indexInfo.srcIndexData.srcBuffer != nullptr) + { + const uint8_t *bufferData = nullptr; + ANGLE_TRY(indexInfo.srcIndexData.srcBuffer->getData(context, &bufferData)); + ASSERT(bufferData != nullptr); + + ptrdiff_t offset = + reinterpret_cast<ptrdiff_t>(indexInfo.srcIndexData.srcIndices); + indexInfo.srcIndexData.srcBuffer = nullptr; + indexInfo.srcIndexData.srcIndices = bufferData + offset; + } + + ANGLE_TRY(bufferStorage->getEmulatedIndexedBuffer(context, &indexInfo.srcIndexData, + attrib, firstVertex, &buffer)); + + mVertexArray11->updateCachedIndexInfo(indexInfo); + } + else + { + ANGLE_TRY(bufferStorage->getBuffer( + context, BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK, &buffer)); + } + + vertexStride = attrib.stride; + ANGLE_TRY(attrib.computeOffset(context, firstVertex, &vertexOffset)); + } + + size_t bufferIndex = reservedBuffers + attribIndex; + + queueVertexBufferChange(bufferIndex, buffer, vertexStride, vertexOffset); + } + + Context11 *context11 = GetImplAs<Context11>(context); + + // Instanced PointSprite emulation requires two additional ID3D11Buffers. A vertex buffer needs + // to be created and added to the list of current buffers, strides and offsets collections. + // This buffer contains the vertices for a single PointSprite quad. + // An index buffer also needs to be created and applied because rendering instanced data on + // D3D11 FL9_3 requires DrawIndexedInstanced() to be used. Shaders that contain gl_PointSize and + // used without the GL_POINTS rendering mode require a vertex buffer because some drivers cannot + // handle missing vertex data and will TDR the system. + if (programUsesInstancedPointSprites) + { + constexpr UINT kPointSpriteVertexStride = sizeof(float) * 5; + + if (!mPointSpriteVertexBuffer.valid()) + { + static constexpr float kPointSpriteVertices[] = { + // Position | TexCoord + -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, /* v0 */ + -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, /* v1 */ + 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, /* v2 */ + 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, /* v3 */ + -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, /* v4 */ + 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, /* v5 */ + }; + + D3D11_SUBRESOURCE_DATA vertexBufferData = {kPointSpriteVertices, 0, 0}; + D3D11_BUFFER_DESC vertexBufferDesc; + vertexBufferDesc.ByteWidth = sizeof(kPointSpriteVertices); + vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + vertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; + vertexBufferDesc.CPUAccessFlags = 0; + vertexBufferDesc.MiscFlags = 0; + vertexBufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, vertexBufferDesc, &vertexBufferData, + &mPointSpriteVertexBuffer)); + } + + // Set the stride to 0 if GL_POINTS mode is not being used to instruct the driver to avoid + // indexing into the vertex buffer. + UINT stride = instancedPointSpritesActive ? kPointSpriteVertexStride : 0; + queueVertexBufferChange(0, mPointSpriteVertexBuffer.get(), stride, 0); + + if (!mPointSpriteIndexBuffer.valid()) + { + // Create an index buffer and set it for pointsprite rendering + static constexpr unsigned short kPointSpriteIndices[] = { + 0, 1, 2, 3, 4, 5, + }; + + D3D11_SUBRESOURCE_DATA indexBufferData = {kPointSpriteIndices, 0, 0}; + D3D11_BUFFER_DESC indexBufferDesc; + indexBufferDesc.ByteWidth = sizeof(kPointSpriteIndices); + indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; + indexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; + indexBufferDesc.CPUAccessFlags = 0; + indexBufferDesc.MiscFlags = 0; + indexBufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(context11, indexBufferDesc, &indexBufferData, + &mPointSpriteIndexBuffer)); + } + + if (instancedPointSpritesActive) + { + // The index buffer is applied here because Instanced PointSprite emulation uses the a + // non-indexed rendering path in ANGLE (DrawArrays). This means that applyIndexBuffer() + // on the renderer will not be called and setting this buffer here ensures that the + // rendering path will contain the correct index buffers. + syncIndexBuffer(mPointSpriteIndexBuffer.get(), DXGI_FORMAT_R16_UINT, 0); + } + } + + applyVertexBufferChanges(); + return angle::Result::Continue; +} + +angle::Result StateManager11::applyIndexBuffer(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices) +{ + if (!mIndexBufferIsDirty) + { + // No streaming or index buffer application necessary. + return angle::Result::Continue; + } + + gl::DrawElementsType destElementType = mVertexArray11->getCachedDestinationIndexType(); + gl::Buffer *elementArrayBuffer = mVertexArray11->getState().getElementArrayBuffer(); + + TranslatedIndexData indexInfo; + ANGLE_TRY(mIndexDataManager.prepareIndexData(context, indexType, destElementType, indexCount, + elementArrayBuffer, indices, &indexInfo)); + + ID3D11Buffer *buffer = nullptr; + DXGI_FORMAT bufferFormat = (indexInfo.indexType == gl::DrawElementsType::UnsignedInt) + ? DXGI_FORMAT_R32_UINT + : DXGI_FORMAT_R16_UINT; + + if (indexInfo.storage) + { + Buffer11 *storage = GetAs<Buffer11>(indexInfo.storage); + ANGLE_TRY(storage->getBuffer(context, BUFFER_USAGE_INDEX, &buffer)); + } + else + { + IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(indexInfo.indexBuffer); + buffer = indexBuffer->getBuffer().get(); + } + + // Track dirty indices in the index range cache. + indexInfo.srcIndexData.srcIndicesChanged = + syncIndexBuffer(buffer, bufferFormat, indexInfo.startOffset); + + mIndexBufferIsDirty = false; + + mVertexArray11->updateCachedIndexInfo(indexInfo); + return angle::Result::Continue; +} + +void StateManager11::setIndexBuffer(ID3D11Buffer *buffer, + DXGI_FORMAT indexFormat, + unsigned int offset) +{ + if (syncIndexBuffer(buffer, indexFormat, offset)) + { + invalidateIndexBuffer(); + } +} + +bool StateManager11::syncIndexBuffer(ID3D11Buffer *buffer, + DXGI_FORMAT indexFormat, + unsigned int offset) +{ + if (buffer != mAppliedIB || indexFormat != mAppliedIBFormat || offset != mAppliedIBOffset) + { + mRenderer->getDeviceContext()->IASetIndexBuffer(buffer, indexFormat, offset); + + mAppliedIB = buffer; + mAppliedIBFormat = indexFormat; + mAppliedIBOffset = offset; + return true; + } + + return false; +} + +// Vertex buffer is invalidated outside this function. +angle::Result StateManager11::updateVertexOffsetsForPointSpritesEmulation( + const gl::Context *context, + GLint startVertex, + GLsizei emulatedInstanceId) +{ + size_t reservedBuffers = GetReservedBufferCount(true); + for (size_t attribIndex = 0; attribIndex < mCurrentAttributes.size(); ++attribIndex) + { + const auto &attrib = *mCurrentAttributes[attribIndex]; + size_t bufferIndex = reservedBuffers + attribIndex; + + if (attrib.divisor > 0) + { + unsigned int offset = 0; + ANGLE_TRY(attrib.computeOffset(context, startVertex, &offset)); + offset += (attrib.stride * (emulatedInstanceId / attrib.divisor)); + if (offset != mCurrentVertexOffsets[bufferIndex]) + { + invalidateInputLayout(); + mDirtyVertexBufferRange.extend(static_cast<unsigned int>(bufferIndex)); + mCurrentVertexOffsets[bufferIndex] = offset; + } + } + } + + applyVertexBufferChanges(); + return angle::Result::Continue; +} + +angle::Result StateManager11::generateSwizzle(const gl::Context *context, gl::Texture *texture) +{ + if (!texture) + { + return angle::Result::Continue; + } + + TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture); + ASSERT(textureD3D); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureD3D->getNativeTexture(context, &texStorage)); + + if (texStorage) + { + TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage); + const gl::TextureState &textureState = texture->getTextureState(); + ANGLE_TRY(storage11->generateSwizzles(context, textureState)); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::generateSwizzlesForShader(const gl::Context *context, + gl::ShaderType type) +{ + const gl::State &glState = context->getState(); + const gl::RangeUI samplerRange = mProgramD3D->getUsedSamplerRange(type); + + for (unsigned int i = samplerRange.low(); i < samplerRange.high(); i++) + { + gl::TextureType textureType = mProgramD3D->getSamplerTextureType(type, i); + GLint textureUnit = mProgramD3D->getSamplerMapping(type, i, context->getCaps()); + if (textureUnit != -1) + { + gl::Texture *texture = glState.getSamplerTexture(textureUnit, textureType); + ASSERT(texture); + if (SwizzleRequired(texture->getTextureState())) + { + ANGLE_TRY(generateSwizzle(context, texture)); + } + } + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::generateSwizzles(const gl::Context *context) +{ + ANGLE_TRY(generateSwizzlesForShader(context, gl::ShaderType::Vertex)); + ANGLE_TRY(generateSwizzlesForShader(context, gl::ShaderType::Fragment)); + return angle::Result::Continue; +} + +angle::Result StateManager11::applyUniformsForShader(const gl::Context *context, + gl::ShaderType shaderType) +{ + UniformStorage11 *shaderUniformStorage = + GetAs<UniformStorage11>(mProgramD3D->getShaderUniformStorage(shaderType)); + ASSERT(shaderUniformStorage); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + const d3d11::Buffer *shaderConstantBuffer = nullptr; + ANGLE_TRY(shaderUniformStorage->getConstantBuffer(context, mRenderer, &shaderConstantBuffer)); + + if (shaderUniformStorage->size() > 0 && mProgramD3D->areShaderUniformsDirty(shaderType)) + { + UpdateUniformBuffer(deviceContext, shaderUniformStorage, shaderConstantBuffer); + } + + unsigned int slot = d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK; + + switch (shaderType) + { + case gl::ShaderType::Vertex: + if (mCurrentConstantBufferVS[slot] != shaderConstantBuffer->getSerial()) + { + deviceContext->VSSetConstantBuffers(slot, 1, shaderConstantBuffer->getPointer()); + mCurrentConstantBufferVS[slot] = shaderConstantBuffer->getSerial(); + mCurrentConstantBufferVSOffset[slot] = 0; + mCurrentConstantBufferVSSize[slot] = 0; + } + break; + + case gl::ShaderType::Fragment: + if (mCurrentConstantBufferPS[slot] != shaderConstantBuffer->getSerial()) + { + deviceContext->PSSetConstantBuffers(slot, 1, shaderConstantBuffer->getPointer()); + mCurrentConstantBufferPS[slot] = shaderConstantBuffer->getSerial(); + mCurrentConstantBufferPSOffset[slot] = 0; + mCurrentConstantBufferPSSize[slot] = 0; + } + break; + + // TODO(jiawei.shao@intel.com): apply geometry shader uniforms + case gl::ShaderType::Geometry: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + break; + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::applyUniforms(const gl::Context *context) +{ + ANGLE_TRY(applyUniformsForShader(context, gl::ShaderType::Vertex)); + ANGLE_TRY(applyUniformsForShader(context, gl::ShaderType::Fragment)); + if (mProgramD3D->hasShaderStage(gl::ShaderType::Geometry)) + { + ANGLE_TRY(applyUniformsForShader(context, gl::ShaderType::Geometry)); + } + + mProgramD3D->markUniformsClean(); + + return angle::Result::Continue; +} + +angle::Result StateManager11::applyDriverUniformsForShader(const gl::Context *context, + gl::ShaderType shaderType) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + d3d11::Buffer &shaderDriverConstantBuffer = mShaderDriverConstantBuffers[shaderType]; + if (!shaderDriverConstantBuffer.valid()) + { + size_t requiredSize = mShaderConstants.getRequiredBufferSize(shaderType); + + D3D11_BUFFER_DESC constantBufferDescription = {}; + d3d11::InitConstantBufferDesc(&constantBufferDescription, requiredSize); + ANGLE_TRY(mRenderer->allocateResource( + GetImplAs<Context11>(context), constantBufferDescription, &shaderDriverConstantBuffer)); + + ID3D11Buffer *driverConstants = shaderDriverConstantBuffer.get(); + switch (shaderType) + { + case gl::ShaderType::Vertex: + deviceContext->VSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1, + &driverConstants); + break; + + case gl::ShaderType::Fragment: + deviceContext->PSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1, + &driverConstants); + break; + + case gl::ShaderType::Geometry: + deviceContext->GSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1, + &driverConstants); + break; + + default: + UNREACHABLE(); + return angle::Result::Continue; + } + } + + // Sampler metadata and driver constants need to coexist in the same constant buffer to + // conserve constant buffer slots. We update both in the constant buffer if needed. + ANGLE_TRY(mShaderConstants.updateBuffer(context, mRenderer, shaderType, *mProgramD3D, + shaderDriverConstantBuffer)); + + return angle::Result::Continue; +} + +angle::Result StateManager11::applyDriverUniforms(const gl::Context *context) +{ + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + ANGLE_TRY(applyDriverUniformsForShader(context, gl::ShaderType::Vertex)); + ANGLE_TRY(applyDriverUniformsForShader(context, gl::ShaderType::Fragment)); + if (mProgramD3D->hasShaderStage(gl::ShaderType::Geometry)) + { + ANGLE_TRY(applyDriverUniformsForShader(context, gl::ShaderType::Geometry)); + } + + // needed for the point sprite geometry shader + // GSSetConstantBuffers triggers device removal on 9_3, so we should only call it for ES3. + if (mRenderer->isES3Capable()) + { + d3d11::Buffer &driverConstantBufferPS = + mShaderDriverConstantBuffers[gl::ShaderType::Fragment]; + if (mCurrentGeometryConstantBuffer != driverConstantBufferPS.getSerial()) + { + ASSERT(driverConstantBufferPS.valid()); + deviceContext->GSSetConstantBuffers(0, 1, driverConstantBufferPS.getPointer()); + mCurrentGeometryConstantBuffer = driverConstantBufferPS.getSerial(); + } + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::applyComputeUniforms(const gl::Context *context, + ProgramD3D *programD3D) +{ + UniformStorage11 *computeUniformStorage = + GetAs<UniformStorage11>(programD3D->getShaderUniformStorage(gl::ShaderType::Compute)); + ASSERT(computeUniformStorage); + + const d3d11::Buffer *constantBuffer = nullptr; + ANGLE_TRY(computeUniformStorage->getConstantBuffer(context, mRenderer, &constantBuffer)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + if (computeUniformStorage->size() > 0 && + programD3D->areShaderUniformsDirty(gl::ShaderType::Compute)) + { + UpdateUniformBuffer(deviceContext, computeUniformStorage, constantBuffer); + programD3D->markUniformsClean(); + } + + if (mCurrentComputeConstantBuffer != constantBuffer->getSerial()) + { + deviceContext->CSSetConstantBuffers( + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, + constantBuffer->getPointer()); + mCurrentComputeConstantBuffer = constantBuffer->getSerial(); + } + + if (!mShaderDriverConstantBuffers[gl::ShaderType::Compute].valid()) + { + size_t requiredSize = mShaderConstants.getRequiredBufferSize(gl::ShaderType::Compute); + + D3D11_BUFFER_DESC constantBufferDescription = {}; + d3d11::InitConstantBufferDesc(&constantBufferDescription, requiredSize); + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), constantBufferDescription, + &mShaderDriverConstantBuffers[gl::ShaderType::Compute])); + ID3D11Buffer *buffer = mShaderDriverConstantBuffers[gl::ShaderType::Compute].get(); + deviceContext->CSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1, + &buffer); + } + + ANGLE_TRY(mShaderConstants.updateBuffer(context, mRenderer, gl::ShaderType::Compute, + *programD3D, + mShaderDriverConstantBuffers[gl::ShaderType::Compute])); + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncUniformBuffersForShader(const gl::Context *context, + gl::ShaderType shaderType) +{ + const auto &glState = context->getState(); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported(); + + const auto &shaderUniformBuffers = mProgramD3D->getShaderUniformBufferCache(shaderType); + + for (size_t bufferIndex = 0; bufferIndex < shaderUniformBuffers.size(); ++bufferIndex) + { + const D3DUBOCache cache = shaderUniformBuffers[bufferIndex]; + if (cache.binding == -1) + { + continue; + } + + const auto &uniformBuffer = glState.getIndexedUniformBuffer(cache.binding); + const GLintptr uniformBufferOffset = uniformBuffer.getOffset(); + const GLsizeiptr uniformBufferSize = uniformBuffer.getSize(); + + if (uniformBuffer.get() == nullptr) + { + continue; + } + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); + const d3d11::Buffer *constantBuffer = nullptr; + UINT firstConstant = 0; + UINT numConstants = 0; + + ANGLE_TRY(bufferStorage->getConstantBufferRange(context, uniformBufferOffset, + uniformBufferSize, &constantBuffer, + &firstConstant, &numConstants)); + ASSERT(constantBuffer); + + switch (shaderType) + { + case gl::ShaderType::Vertex: + { + if (mCurrentConstantBufferVS[cache.registerIndex] == constantBuffer->getSerial() && + mCurrentConstantBufferVSOffset[cache.registerIndex] == uniformBufferOffset && + mCurrentConstantBufferVSSize[cache.registerIndex] == uniformBufferSize) + { + continue; + } + + if (firstConstant != 0 && uniformBufferSize != 0) + { + ASSERT(numConstants != 0); + deviceContext1->VSSetConstantBuffers1(cache.registerIndex, 1, + constantBuffer->getPointer(), + &firstConstant, &numConstants); + } + else + { + deviceContext->VSSetConstantBuffers(cache.registerIndex, 1, + constantBuffer->getPointer()); + } + + mCurrentConstantBufferVS[cache.registerIndex] = constantBuffer->getSerial(); + mCurrentConstantBufferVSOffset[cache.registerIndex] = uniformBufferOffset; + mCurrentConstantBufferVSSize[cache.registerIndex] = uniformBufferSize; + break; + } + + case gl::ShaderType::Fragment: + { + if (mCurrentConstantBufferPS[cache.registerIndex] == constantBuffer->getSerial() && + mCurrentConstantBufferPSOffset[cache.registerIndex] == uniformBufferOffset && + mCurrentConstantBufferPSSize[cache.registerIndex] == uniformBufferSize) + { + continue; + } + + if (firstConstant != 0 && uniformBufferSize != 0) + { + deviceContext1->PSSetConstantBuffers1(cache.registerIndex, 1, + constantBuffer->getPointer(), + &firstConstant, &numConstants); + } + else + { + deviceContext->PSSetConstantBuffers(cache.registerIndex, 1, + constantBuffer->getPointer()); + } + + mCurrentConstantBufferPS[cache.registerIndex] = constantBuffer->getSerial(); + mCurrentConstantBufferPSOffset[cache.registerIndex] = uniformBufferOffset; + mCurrentConstantBufferPSSize[cache.registerIndex] = uniformBufferSize; + break; + } + + case gl::ShaderType::Compute: + { + if (mCurrentConstantBufferCS[bufferIndex] == constantBuffer->getSerial() && + mCurrentConstantBufferCSOffset[bufferIndex] == uniformBufferOffset && + mCurrentConstantBufferCSSize[bufferIndex] == uniformBufferSize) + { + continue; + } + + if (firstConstant != 0 && uniformBufferSize != 0) + { + deviceContext1->CSSetConstantBuffers1(cache.registerIndex, 1, + constantBuffer->getPointer(), + &firstConstant, &numConstants); + } + else + { + deviceContext->CSSetConstantBuffers(cache.registerIndex, 1, + constantBuffer->getPointer()); + } + + mCurrentConstantBufferCS[cache.registerIndex] = constantBuffer->getSerial(); + mCurrentConstantBufferCSOffset[cache.registerIndex] = uniformBufferOffset; + mCurrentConstantBufferCSSize[cache.registerIndex] = uniformBufferSize; + break; + } + + // TODO(jiawei.shao@intel.com): update geometry shader uniform buffers. + case gl::ShaderType::Geometry: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + } + } + + const auto &shaderUniformBuffersUseSB = + mProgramD3D->getShaderUniformBufferCacheUseSB(shaderType); + for (size_t bufferIndex = 0; bufferIndex < shaderUniformBuffersUseSB.size(); ++bufferIndex) + { + const D3DUBOCacheUseSB cache = shaderUniformBuffersUseSB[bufferIndex]; + if (cache.binding == -1) + { + continue; + } + + const auto &uniformBuffer = glState.getIndexedUniformBuffer(cache.binding); + if (uniformBuffer.get() == nullptr) + { + continue; + } + const GLintptr uniformBufferOffset = uniformBuffer.getOffset(); + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); + const d3d11::ShaderResourceView *bufferSRV = nullptr; + ANGLE_TRY(bufferStorage->getStructuredBufferRangeSRV( + context, static_cast<unsigned int>(uniformBufferOffset), cache.byteWidth, + cache.structureByteStride, &bufferSRV)); + + ASSERT(bufferSRV->valid()); + setShaderResourceInternal(shaderType, cache.registerIndex, bufferSRV); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::getUAVsForShaderStorageBuffers(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList) +{ + const gl::State &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + angle::FixedVector<Buffer11 *, gl::IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS> + previouslyBound; + for (size_t blockIndex = 0; blockIndex < program->getActiveShaderStorageBlockCount(); + blockIndex++) + { + GLuint binding = program->getShaderStorageBlockBinding(static_cast<GLuint>(blockIndex)); + const unsigned int registerIndex = mProgramD3D->getShaderStorageBufferRegisterIndex( + static_cast<GLuint>(blockIndex), shaderType); + // It means this block is active but not statically used. + if (registerIndex == GL_INVALID_INDEX) + { + continue; + } + const auto &shaderStorageBuffer = glState.getIndexedShaderStorageBuffer(binding); + if (shaderStorageBuffer.get() == nullptr) + { + // We didn't see a driver error like atomic buffer did. But theoretically, the same + // thing should be done. + setUnorderedAccessViewInternal<d3d11::UnorderedAccessView>(registerIndex, nullptr, + uavList); + continue; + } + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(shaderStorageBuffer.get()); + if (std::find(previouslyBound.begin(), previouslyBound.end(), bufferStorage) != + previouslyBound.end()) + { + // D3D11 doesn't support binding a buffer multiple times + // http://anglebug.com/3032 + ERR() << "Writing to multiple blocks on the same buffer is not allowed."; + return angle::Result::Stop; + } + previouslyBound.push_back(bufferStorage); + + d3d11::UnorderedAccessView *uavPtr = nullptr; + GLsizeiptr viewSize = 0; + // Bindings only have a valid size if bound using glBindBufferRange + if (shaderStorageBuffer.getSize() > 0) + { + viewSize = shaderStorageBuffer.getSize(); + } + // We use the buffer size for glBindBufferBase + else + { + viewSize = bufferStorage->getSize(); + } + ANGLE_TRY(bufferStorage->getRawUAVRange(context, shaderStorageBuffer.getOffset(), viewSize, + &uavPtr)); + + setUnorderedAccessViewInternal(registerIndex, uavPtr, uavList); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncUniformBuffers(const gl::Context *context) +{ + mProgramD3D->updateUniformBufferCache(context->getCaps()); + + if (mProgramD3D->hasShaderStage(gl::ShaderType::Compute)) + { + ANGLE_TRY(syncUniformBuffersForShader(context, gl::ShaderType::Compute)); + } + else + { + ANGLE_TRY(syncUniformBuffersForShader(context, gl::ShaderType::Vertex)); + ANGLE_TRY(syncUniformBuffersForShader(context, gl::ShaderType::Fragment)); + if (mProgramD3D->hasShaderStage(gl::ShaderType::Geometry)) + { + ANGLE_TRY(syncUniformBuffersForShader(context, gl::ShaderType::Geometry)); + } + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::getUAVsForAtomicCounterBuffers(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList) +{ + const gl::State &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + for (const auto &atomicCounterBuffer : program->getState().getAtomicCounterBuffers()) + { + GLuint binding = atomicCounterBuffer.binding; + const auto &buffer = glState.getIndexedAtomicCounterBuffer(binding); + const unsigned int registerIndex = + mProgramD3D->getAtomicCounterBufferRegisterIndex(binding, shaderType); + ASSERT(registerIndex != GL_INVALID_INDEX); + if (buffer.get() == nullptr) + { + // The atomic counter is used in shader. However, there is no buffer binding to it. We + // should clear the corresponding UAV in case the previous view type is a texture not a + // buffer. Otherwise, below error will be reported. The Unordered Access View dimension + // declared in the shader code (BUFFER) does not match the view type bound to slot 0 + // of the Compute Shader unit (TEXTURE2D). + setUnorderedAccessViewInternal<d3d11::UnorderedAccessView>(registerIndex, nullptr, + uavList); + continue; + } + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(buffer.get()); + // TODO(enrico.galli@intel.com): Check to make sure that we aren't binding the same buffer + // multiple times, as this is unsupported by D3D11. http://anglebug.com/3141 + + // Bindings only have a valid size if bound using glBindBufferRange. Therefore, we use the + // buffer size for glBindBufferBase + GLsizeiptr viewSize = (buffer.getSize() > 0) ? buffer.getSize() : bufferStorage->getSize(); + d3d11::UnorderedAccessView *uavPtr = nullptr; + ANGLE_TRY(bufferStorage->getRawUAVRange(context, buffer.getOffset(), viewSize, &uavPtr)); + + setUnorderedAccessViewInternal(registerIndex, uavPtr, uavList); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::getUAVsForShader(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList) +{ + ANGLE_TRY(getUAVsForShaderStorageBuffers(context, shaderType, uavList)); + ANGLE_TRY(getUAVsForRWImages(context, shaderType, uavList)); + ANGLE_TRY(getUAVsForAtomicCounterBuffers(context, shaderType, uavList)); + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncUAVsForGraphics(const gl::Context *context) +{ + UAVList uavList(mRenderer->getNativeCaps().maxImageUnits); + + ANGLE_TRY(getUAVsForShader(context, gl::ShaderType::Fragment, &uavList)); + ANGLE_TRY(getUAVsForShader(context, gl::ShaderType::Vertex, &uavList)); + + if (uavList.highestUsed >= 0) + { + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + UINT baseUAVRegister = static_cast<UINT>(mProgramD3D->getPixelShaderKey().size()); + deviceContext->OMSetRenderTargetsAndUnorderedAccessViews( + D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL, nullptr, nullptr, baseUAVRegister, + uavList.highestUsed + 1, uavList.data.data(), nullptr); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncUAVsForCompute(const gl::Context *context) +{ + UAVList uavList(mRenderer->getNativeCaps().maxImageUnits); + + ANGLE_TRY(getUAVsForShader(context, gl::ShaderType::Compute, &uavList)); + + if (uavList.highestUsed >= 0) + { + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->CSSetUnorderedAccessViews(0, uavList.highestUsed + 1, uavList.data.data(), + nullptr); + } + + return angle::Result::Continue; +} + +angle::Result StateManager11::syncTransformFeedbackBuffers(const gl::Context *context) +{ + const auto &glState = context->getState(); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // If transform feedback is not active, unbind all buffers + if (!glState.isTransformFeedbackActiveUnpaused()) + { + if (mAppliedTFSerial != mEmptySerial) + { + deviceContext->SOSetTargets(0, nullptr, nullptr); + mAppliedTFSerial = mEmptySerial; + } + return angle::Result::Continue; + } + + gl::TransformFeedback *transformFeedback = glState.getCurrentTransformFeedback(); + TransformFeedback11 *tf11 = GetImplAs<TransformFeedback11>(transformFeedback); + if (mAppliedTFSerial == tf11->getSerial() && !tf11->isDirty()) + { + return angle::Result::Continue; + } + + const std::vector<ID3D11Buffer *> *soBuffers = nullptr; + ANGLE_TRY(tf11->getSOBuffers(context, &soBuffers)); + const std::vector<UINT> &soOffsets = tf11->getSOBufferOffsets(); + + deviceContext->SOSetTargets(tf11->getNumSOBuffers(), soBuffers->data(), soOffsets.data()); + + mAppliedTFSerial = tf11->getSerial(); + tf11->onApply(); + + return angle::Result::Continue; +} + +void StateManager11::syncPrimitiveTopology(const gl::State &glState, + gl::PrimitiveMode currentDrawMode) +{ + D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + // Don't cull everything by default, this also resets if we were previously culling + mCullEverything = false; + + switch (currentDrawMode) + { + case gl::PrimitiveMode::Points: + { + bool usesPointSize = mProgramD3D->usesPointSize(); + + // ProgramBinary assumes non-point rendering if gl_PointSize isn't written, + // which affects varying interpolation. Since the value of gl_PointSize is + // undefined when not written, just skip drawing to avoid unexpected results. + if (!usesPointSize && !glState.isTransformFeedbackActiveUnpaused()) + { + // Notify developers of risking undefined behavior. + WARN() << "Point rendering without writing to gl_PointSize."; + mCullEverything = true; + return; + } + + // If instanced pointsprites are enabled and the shader uses gl_PointSize, the topology + // must be D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST. + if (usesPointSize && mRenderer->getFeatures().useInstancedPointSpriteEmulation.enabled) + { + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + } + else + { + primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST; + } + break; + } + case gl::PrimitiveMode::Lines: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINELIST; + break; + case gl::PrimitiveMode::LineLoop: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP; + break; + case gl::PrimitiveMode::LineStrip: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP; + break; + case gl::PrimitiveMode::Triangles: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + mCullEverything = CullsEverything(glState); + break; + case gl::PrimitiveMode::TriangleStrip: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; + mCullEverything = CullsEverything(glState); + break; + // emulate fans via rewriting index buffer + case gl::PrimitiveMode::TriangleFan: + primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + mCullEverything = CullsEverything(glState); + break; + default: + UNREACHABLE(); + break; + } + + setPrimitiveTopologyInternal(primitiveTopology); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.h new file mode 100644 index 0000000000..d8438a48dc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StateManager11.h @@ -0,0 +1,692 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StateManager11.h: Defines a class for caching D3D11 state + +#ifndef LIBANGLE_RENDERER_D3D11_STATEMANAGER11_H_ +#define LIBANGLE_RENDERER_D3D11_STATEMANAGER11_H_ + +#include <array> + +#include "libANGLE/State.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/d3d11/InputLayoutCache.h" +#include "libANGLE/renderer/d3d/d3d11/Query11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ +class Buffer11; +class DisplayD3D; +class Framebuffer11; +struct RenderTargetDesc; +struct Renderer11DeviceCaps; +class VertexArray11; + +class ShaderConstants11 : angle::NonCopyable +{ + public: + ShaderConstants11(); + ~ShaderConstants11(); + + void init(const gl::Caps &caps); + size_t getRequiredBufferSize(gl::ShaderType shaderType) const; + void markDirty(); + + void setComputeWorkGroups(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ); + void setMultiviewWriteToViewportIndex(GLfloat index); + void onViewportChange(const gl::Rectangle &glViewport, + const D3D11_VIEWPORT &dxViewport, + const gl::Offset &glFragCoordOffset, + bool is9_3, + bool presentPathFast); + bool onFirstVertexChange(GLint firstVertex); + void onImageLayerChange(gl::ShaderType shaderType, unsigned int imageIndex, int layer); + void onSamplerChange(gl::ShaderType shaderType, + unsigned int samplerIndex, + const gl::Texture &texture, + const gl::SamplerState &samplerState); + bool onImageChange(gl::ShaderType shaderType, + unsigned int imageIndex, + const gl::ImageUnit &imageUnit); + void onClipControlChange(bool lowerLeft, bool zeroToOne); + + angle::Result updateBuffer(const gl::Context *context, + Renderer11 *renderer, + gl::ShaderType shaderType, + const ProgramD3D &programD3D, + const d3d11::Buffer &driverConstantBuffer); + + private: + struct Vertex + { + Vertex() + : depthRange{.0f}, + viewAdjust{.0f}, + viewCoords{.0f}, + viewScale{.0f}, + multiviewWriteToViewportIndex{.0f}, + clipControlOrigin{-1.0f}, + clipControlZeroToOne{.0f}, + firstVertex{0}, + padding{.0f, .0f} + {} + + float depthRange[4]; + float viewAdjust[4]; + float viewCoords[4]; + float viewScale[2]; + // multiviewWriteToViewportIndex is used to select either the side-by-side or layered + // code-path in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated + // whenever a multi-view draw framebuffer is made active. + float multiviewWriteToViewportIndex; + + // EXT_clip_control + // Multiplied with Y coordinate: -1.0 for GL_LOWER_LEFT_EXT, 1.0f for GL_UPPER_LEFT_EXT + float clipControlOrigin; + // 0.0 for GL_NEGATIVE_ONE_TO_ONE_EXT, 1.0 for GL_ZERO_TO_ONE_EXT + float clipControlZeroToOne; + + uint32_t firstVertex; + + // Added here to manually pad the struct to 16 byte boundary + float padding[2]; + }; + static_assert(sizeof(Vertex) % 16u == 0, + "D3D11 constant buffers must be multiples of 16 bytes"); + + struct Pixel + { + Pixel() + : depthRange{.0f}, + viewCoords{.0f}, + depthFront{.0f}, + fragCoordOffset{.0f}, + viewScale{.0f}, + multiviewWriteToViewportIndex{.0f}, + padding{.0f} + {} + + float depthRange[4]; + float viewCoords[4]; + float depthFront[4]; + float fragCoordOffset[2]; + float viewScale[2]; + // multiviewWriteToViewportIndex is used to select either the side-by-side or layered + // code-path in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated + // whenever a multi-view draw framebuffer is made active. + float multiviewWriteToViewportIndex; + + // Added here to manually pad the struct. + float padding[3]; + }; + static_assert(sizeof(Pixel) % 16u == 0, "D3D11 constant buffers must be multiples of 16 bytes"); + + struct Compute + { + Compute() : numWorkGroups{0u}, padding(0u) {} + unsigned int numWorkGroups[3]; + unsigned int padding; // This just pads the struct to 16 bytes + }; + + struct SamplerMetadata + { + SamplerMetadata() + : baseLevel(0), internalFormatBits(0), wrapModes(0), padding(0), intBorderColor{0} + {} + + int baseLevel; + int internalFormatBits; + int wrapModes; + int padding; // This just pads the struct to 32 bytes + int intBorderColor[4]; + }; + + static_assert(sizeof(SamplerMetadata) == 32u, + "Sampler metadata struct must be two 4-vec --> 32 bytes."); + + struct ImageMetadata + { + ImageMetadata() : layer(0), level(0), padding{0} {} + + int layer; + unsigned int level; + int padding[2]; // This just pads the struct to 16 bytes + }; + static_assert(sizeof(ImageMetadata) == 16u, + "Image metadata struct must be one 4-vec --> 16 bytes."); + + static size_t GetShaderConstantsStructSize(gl::ShaderType shaderType); + + // Return true if dirty. + bool updateSamplerMetadata(SamplerMetadata *data, + const gl::Texture &texture, + const gl::SamplerState &samplerState); + + // Return true if dirty. + bool updateImageMetadata(ImageMetadata *data, const gl::ImageUnit &imageUnit); + + Vertex mVertex; + Pixel mPixel; + Compute mCompute; + gl::ShaderBitSet mShaderConstantsDirty; + + gl::ShaderMap<std::vector<SamplerMetadata>> mShaderSamplerMetadata; + gl::ShaderMap<int> mNumActiveShaderSamplers; + gl::ShaderMap<std::vector<ImageMetadata>> mShaderReadonlyImageMetadata; + gl::ShaderMap<int> mNumActiveShaderReadonlyImages; + gl::ShaderMap<std::vector<ImageMetadata>> mShaderImageMetadata; + gl::ShaderMap<int> mNumActiveShaderImages; +}; + +class StateManager11 final : angle::NonCopyable +{ + public: + StateManager11(Renderer11 *renderer); + ~StateManager11(); + + void deinitialize(); + + void syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + gl::Command command); + + angle::Result updateStateForCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ); + + void updateStencilSizeIfChanged(bool depthStencilInitialized, unsigned int stencilSize); + + // These invalidations methods are called externally. + + // Called from TextureStorage11. + void invalidateBoundViews(); + + // Called from VertexArray11::updateVertexAttribStorage. + void invalidateCurrentValueAttrib(size_t attribIndex); + + // Checks are done on a framebuffer state change to trigger other state changes. + // The Context is allowed to be nullptr for these methods, when called in EGL init code. + void invalidateRenderTarget(); + + // Called by instanced point sprite emulation. + void invalidateVertexBuffer(); + + // Called by Framebuffer11::syncState for the default sized viewport. + void invalidateViewport(const gl::Context *context); + + // Called by TextureStorage11::markLevelDirty. + void invalidateSwizzles(); + + // Called by the Framebuffer11 and VertexArray11. + void invalidateShaders(); + + // Called by the Program on Uniform Buffer change. Also called internally. + void invalidateProgramUniformBuffers(); + + // Called by TransformFeedback11. + void invalidateTransformFeedback(); + + // Called by VertexArray11. + void invalidateInputLayout(); + + // Called by VertexArray11 element array buffer sync. + void invalidateIndexBuffer(); + + // Called by TextureStorage11. Also called internally. + void invalidateTexturesAndSamplers(); + + void setRenderTarget(ID3D11RenderTargetView *rtv, ID3D11DepthStencilView *dsv); + void setRenderTargets(ID3D11RenderTargetView **rtvs, UINT numRtvs, ID3D11DepthStencilView *dsv); + + void onBeginQuery(Query11 *query); + void onDeleteQueryObject(Query11 *query); + angle::Result onMakeCurrent(const gl::Context *context); + + void setInputLayout(const d3d11::InputLayout *inputLayout); + + void setSingleVertexBuffer(const d3d11::Buffer *buffer, UINT stride, UINT offset); + + angle::Result updateState(const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic); + + void setShaderResourceShared(gl::ShaderType shaderType, + UINT resourceSlot, + const d3d11::SharedSRV *srv); + void setShaderResource(gl::ShaderType shaderType, + UINT resourceSlot, + const d3d11::ShaderResourceView *srv); + void setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology); + + void setDrawShaders(const d3d11::VertexShader *vertexShader, + const d3d11::GeometryShader *geometryShader, + const d3d11::PixelShader *pixelShader); + void setVertexShader(const d3d11::VertexShader *shader); + void setGeometryShader(const d3d11::GeometryShader *shader); + void setPixelShader(const d3d11::PixelShader *shader); + void setComputeShader(const d3d11::ComputeShader *shader); + void setVertexConstantBuffer(unsigned int slot, const d3d11::Buffer *buffer); + void setPixelConstantBuffer(unsigned int slot, const d3d11::Buffer *buffer); + void setDepthStencilState(const d3d11::DepthStencilState *depthStencilState, UINT stencilRef); + void setSimpleBlendState(const d3d11::BlendState *blendState); + void setRasterizerState(const d3d11::RasterizerState *rasterizerState); + void setSimpleViewport(const gl::Extents &viewportExtents); + void setSimpleViewport(int width, int height); + void setSimplePixelTextureAndSampler(const d3d11::SharedSRV &srv, + const d3d11::SamplerState &samplerState); + void setSimpleScissorRect(const gl::Rectangle &glRect); + void setScissorRectD3D(const D3D11_RECT &d3dRect); + + void setIndexBuffer(ID3D11Buffer *buffer, DXGI_FORMAT indexFormat, unsigned int offset); + + angle::Result updateVertexOffsetsForPointSpritesEmulation(const gl::Context *context, + GLint startVertex, + GLsizei emulatedInstanceId); + + // TODO(jmadill): Should be private. + angle::Result applyComputeUniforms(const gl::Context *context, ProgramD3D *programD3D); + + // Only used in testing. + InputLayoutCache *getInputLayoutCache() { return &mInputLayoutCache; } + + bool getCullEverything() const { return mCullEverything; } + VertexDataManager *getVertexDataManager() { return &mVertexDataManager; } + + ProgramD3D *getProgramD3D() const { return mProgramD3D; } + + private: + angle::Result ensureInitialized(const gl::Context *context); + + template <typename SRVType> + void setShaderResourceInternal(gl::ShaderType shaderType, + UINT resourceSlot, + const SRVType *srv); + + struct UAVList + { + UAVList(size_t size) : data(size) {} + std::vector<ID3D11UnorderedAccessView *> data; + int highestUsed = -1; + }; + + template <typename UAVType> + void setUnorderedAccessViewInternal(UINT resourceSlot, const UAVType *uav, UAVList *uavList); + + void unsetConflictingView(gl::PipelineType pipeline, ID3D11View *view, bool isRenderTarget); + void unsetConflictingSRVs(gl::PipelineType pipeline, + gl::ShaderType shaderType, + uintptr_t resource, + const gl::ImageIndex *index, + bool isRenderTarget); + void unsetConflictingUAVs(gl::PipelineType pipeline, + gl::ShaderType shaderType, + uintptr_t resource, + const gl::ImageIndex *index); + void unsetConflictingRTVs(uintptr_t resource); + + void unsetConflictingAttachmentResources(const gl::FramebufferAttachment &attachment, + ID3D11Resource *resource); + + angle::Result syncBlendState(const gl::Context *context, + const gl::BlendStateExt &blendStateExt, + const gl::ColorF &blendColor, + unsigned int sampleMask, + bool sampleAlphaToCoverage, + bool emulateConstantAlpha); + + angle::Result syncDepthStencilState(const gl::Context *context); + + angle::Result syncRasterizerState(const gl::Context *context, gl::PrimitiveMode mode); + + void syncScissorRectangle(const gl::Context *context); + + void syncViewport(const gl::Context *context); + + void checkPresentPath(const gl::Context *context); + + angle::Result syncFramebuffer(const gl::Context *context); + angle::Result syncProgram(const gl::Context *context, gl::PrimitiveMode drawMode); + angle::Result syncProgramForCompute(const gl::Context *context); + + angle::Result syncTextures(const gl::Context *context); + angle::Result applyTexturesForSRVs(const gl::Context *context, gl::ShaderType shaderType); + angle::Result applyTexturesForUAVs(const gl::Context *context, gl::ShaderType shaderType); + angle::Result syncTexturesForCompute(const gl::Context *context); + + angle::Result setSamplerState(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &sampler); + angle::Result setTextureForSampler(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &sampler); + angle::Result setImageState(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit); + angle::Result setTextureForImage(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit); + angle::Result getUAVsForRWImages(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList); + angle::Result getUAVForRWImage(const gl::Context *context, + gl::ShaderType type, + int index, + const gl::ImageUnit &imageUnit, + UAVList *uavList); + + void handleMultiviewDrawFramebufferChange(const gl::Context *context); + + angle::Result syncCurrentValueAttribs( + const gl::Context *context, + const std::vector<gl::VertexAttribCurrentValueData> ¤tValues); + + angle::Result generateSwizzle(const gl::Context *context, gl::Texture *texture); + angle::Result generateSwizzlesForShader(const gl::Context *context, gl::ShaderType type); + angle::Result generateSwizzles(const gl::Context *context); + + angle::Result applyDriverUniforms(const gl::Context *context); + angle::Result applyDriverUniformsForShader(const gl::Context *context, + gl::ShaderType shaderType); + angle::Result applyUniforms(const gl::Context *context); + angle::Result applyUniformsForShader(const gl::Context *context, gl::ShaderType shaderType); + + angle::Result getUAVsForShaderStorageBuffers(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList); + + angle::Result syncUniformBuffers(const gl::Context *context); + angle::Result syncUniformBuffersForShader(const gl::Context *context, + gl::ShaderType shaderType); + angle::Result getUAVsForAtomicCounterBuffers(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList); + angle::Result getUAVsForShader(const gl::Context *context, + gl::ShaderType shaderType, + UAVList *uavList); + angle::Result syncUAVsForGraphics(const gl::Context *context); + angle::Result syncUAVsForCompute(const gl::Context *context); + angle::Result syncTransformFeedbackBuffers(const gl::Context *context); + + // These are currently only called internally. + void invalidateDriverUniforms(); + void invalidateProgramUniforms(); + void invalidateConstantBuffer(unsigned int slot); + void invalidateProgramAtomicCounterBuffers(); + void invalidateProgramShaderStorageBuffers(); + void invalidateImageBindings(); + + // Called by the Framebuffer11 directly. + void processFramebufferInvalidation(const gl::Context *context); + + bool syncIndexBuffer(ID3D11Buffer *buffer, DXGI_FORMAT indexFormat, unsigned int offset); + angle::Result syncVertexBuffersAndInputLayout(const gl::Context *context, + gl::PrimitiveMode mode, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + GLsizei instanceCount); + + bool setInputLayoutInternal(const d3d11::InputLayout *inputLayout); + + angle::Result applyVertexBuffers(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType indexTypeOrInvalid, + GLint firstVertex); + // TODO(jmadill): Migrate to d3d11::Buffer. + bool queueVertexBufferChange(size_t bufferIndex, + ID3D11Buffer *buffer, + UINT stride, + UINT offset); + void applyVertexBufferChanges(); + bool setPrimitiveTopologyInternal(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology); + void syncPrimitiveTopology(const gl::State &glState, gl::PrimitiveMode currentDrawMode); + + // Not handled by an internal dirty bit because it isn't synced on drawArrays calls. + angle::Result applyIndexBuffer(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices); + + enum DirtyBitType + { + DIRTY_BIT_RENDER_TARGET, + DIRTY_BIT_VIEWPORT_STATE, + DIRTY_BIT_SCISSOR_STATE, + DIRTY_BIT_RASTERIZER_STATE, + DIRTY_BIT_BLEND_STATE, + DIRTY_BIT_DEPTH_STENCIL_STATE, + // DIRTY_BIT_SHADERS and DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE should be dealt before + // DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS for update image layers. + DIRTY_BIT_SHADERS, + // DIRTY_BIT_GRAPHICS_SRV_STATE and DIRTY_BIT_COMPUTE_SRV_STATE should be lower + // bits than DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE. + DIRTY_BIT_GRAPHICS_SRV_STATE, + DIRTY_BIT_GRAPHICS_UAV_STATE, + DIRTY_BIT_COMPUTE_SRV_STATE, + DIRTY_BIT_COMPUTE_UAV_STATE, + DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE, + DIRTY_BIT_PROGRAM_UNIFORMS, + DIRTY_BIT_DRIVER_UNIFORMS, + DIRTY_BIT_PROGRAM_UNIFORM_BUFFERS, + DIRTY_BIT_CURRENT_VALUE_ATTRIBS, + DIRTY_BIT_TRANSFORM_FEEDBACK, + DIRTY_BIT_VERTEX_BUFFERS_AND_INPUT_LAYOUT, + DIRTY_BIT_PRIMITIVE_TOPOLOGY, + DIRTY_BIT_INVALID, + DIRTY_BIT_MAX = DIRTY_BIT_INVALID, + }; + + using DirtyBits = angle::BitSet<DIRTY_BIT_MAX>; + + Renderer11 *mRenderer; + + // Internal dirty bits. + DirtyBits mInternalDirtyBits; + DirtyBits mGraphicsDirtyBitsMask; + DirtyBits mComputeDirtyBitsMask; + + bool mCurSampleAlphaToCoverage; + + // Blend State + gl::BlendStateExt mCurBlendStateExt; + gl::ColorF mCurBlendColor; + unsigned int mCurSampleMask; + + // Currently applied depth stencil state + gl::DepthStencilState mCurDepthStencilState; + int mCurStencilRef; + int mCurStencilBackRef; + unsigned int mCurStencilSize; + Optional<bool> mCurDisableDepth; + Optional<bool> mCurDisableStencil; + + // Currently applied rasterizer state + gl::RasterizerState mCurRasterState; + + // Currently applied scissor rectangle state + bool mCurScissorEnabled; + gl::Rectangle mCurScissorRect; + + // Currently applied viewport state + gl::Rectangle mCurViewport; + float mCurNear; + float mCurFar; + + // Currently applied offset to viewport and scissor + gl::Offset mCurViewportOffset; + gl::Offset mCurScissorOffset; + + // Things needed in viewport state + ShaderConstants11 mShaderConstants; + + // Render target variables + gl::Extents mViewportBounds; + bool mRenderTargetIsDirty; + + // EGL_ANGLE_experimental_present_path variables + bool mCurPresentPathFastEnabled; + int mCurPresentPathFastColorBufferHeight; + + // Queries that are currently active in this state + std::set<Query11 *> mCurrentQueries; + + // Currently applied textures + template <typename DescType> + struct ViewRecord + { + uintptr_t view; + uintptr_t resource; + DescType desc; + }; + + // A cache of current Views that also tracks the highest 'used' (non-NULL) View. + // We might want to investigate a more robust approach that is also fast when there's + // a large gap between used Views (e.g. if View 0 and 7 are non-NULL, this approach will + // waste time on Views 1-6.) + template <typename ViewType, typename DescType> + class ViewCache : angle::NonCopyable + { + public: + ViewCache(); + ~ViewCache(); + + void initialize(size_t size) { mCurrentViews.resize(size); } + + size_t size() const { return mCurrentViews.size(); } + size_t highestUsed() const { return mHighestUsedView; } + + const ViewRecord<DescType> &operator[](size_t index) const { return mCurrentViews[index]; } + void clear(); + void update(size_t resourceIndex, ViewType *view); + + private: + std::vector<ViewRecord<DescType>> mCurrentViews; + size_t mHighestUsedView; + }; + + using SRVCache = ViewCache<ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC>; + using UAVCache = ViewCache<ID3D11UnorderedAccessView, D3D11_UNORDERED_ACCESS_VIEW_DESC>; + using RTVCache = ViewCache<ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC>; + gl::ShaderMap<SRVCache> mCurShaderSRVs; + UAVCache mCurComputeUAVs; + RTVCache mCurRTVs; + + SRVCache *getSRVCache(gl::ShaderType shaderType); + + // A block of NULL pointers, cached so we don't re-allocate every draw call + std::vector<ID3D11ShaderResourceView *> mNullSRVs; + std::vector<ID3D11UnorderedAccessView *> mNullUAVs; + + // Current translations of "Current-Value" data - owned by Context, not VertexArray. + gl::AttributesMask mDirtyCurrentValueAttribs; + std::vector<TranslatedAttribute> mCurrentValueAttribs; + + // Current applied input layout. + ResourceSerial mCurrentInputLayout; + + // Current applied vertex states. + // TODO(jmadill): Figure out how to use ResourceSerial here. + gl::AttribArray<ID3D11Buffer *> mCurrentVertexBuffers; + gl::AttribArray<UINT> mCurrentVertexStrides; + gl::AttribArray<UINT> mCurrentVertexOffsets; + gl::RangeUI mDirtyVertexBufferRange; + + // Currently applied primitive topology + D3D11_PRIMITIVE_TOPOLOGY mCurrentPrimitiveTopology; + gl::PrimitiveMode mLastAppliedDrawMode; + bool mCullEverything; + + // Currently applied shaders + gl::ShaderMap<ResourceSerial> mAppliedShaders; + + // Currently applied sampler states + gl::ShaderMap<std::vector<bool>> mForceSetShaderSamplerStates; + gl::ShaderMap<std::vector<gl::SamplerState>> mCurShaderSamplerStates; + + // Special dirty bit for swizzles. Since they use internal shaders, must be done in a pre-pass. + bool mDirtySwizzles; + + // Currently applied index buffer + ID3D11Buffer *mAppliedIB; + DXGI_FORMAT mAppliedIBFormat; + unsigned int mAppliedIBOffset; + bool mIndexBufferIsDirty; + + // Vertex, index and input layouts + VertexDataManager mVertexDataManager; + IndexDataManager mIndexDataManager; + InputLayoutCache mInputLayoutCache; + std::vector<const TranslatedAttribute *> mCurrentAttributes; + Optional<GLint> mLastFirstVertex; + + // ANGLE_multiview. + bool mIsMultiviewEnabled; + + bool mIndependentBlendStates; + + // Driver Constants. + gl::ShaderMap<d3d11::Buffer> mShaderDriverConstantBuffers; + + ResourceSerial mCurrentComputeConstantBuffer; + ResourceSerial mCurrentGeometryConstantBuffer; + + d3d11::Buffer mPointSpriteVertexBuffer; + d3d11::Buffer mPointSpriteIndexBuffer; + + template <typename T> + using VertexConstantBufferArray = + std::array<T, gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS>; + + VertexConstantBufferArray<ResourceSerial> mCurrentConstantBufferVS; + VertexConstantBufferArray<GLintptr> mCurrentConstantBufferVSOffset; + VertexConstantBufferArray<GLsizeiptr> mCurrentConstantBufferVSSize; + + template <typename T> + using FragmentConstantBufferArray = + std::array<T, gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS>; + + FragmentConstantBufferArray<ResourceSerial> mCurrentConstantBufferPS; + FragmentConstantBufferArray<GLintptr> mCurrentConstantBufferPSOffset; + FragmentConstantBufferArray<GLsizeiptr> mCurrentConstantBufferPSSize; + + template <typename T> + using ComputeConstantBufferArray = + std::array<T, gl::IMPLEMENTATION_MAX_COMPUTE_SHADER_UNIFORM_BUFFERS>; + + ComputeConstantBufferArray<ResourceSerial> mCurrentConstantBufferCS; + ComputeConstantBufferArray<GLintptr> mCurrentConstantBufferCSOffset; + ComputeConstantBufferArray<GLsizeiptr> mCurrentConstantBufferCSSize; + + // Currently applied transform feedback buffers + Serial mAppliedTFSerial; + + Serial mEmptySerial; + + // These objects are cached to avoid having to query the impls. + ProgramD3D *mProgramD3D; + VertexArray11 *mVertexArray11; + Framebuffer11 *mFramebuffer11; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D11_STATEMANAGER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.cpp new file mode 100644 index 0000000000..e77eba71da --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.cpp @@ -0,0 +1,166 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StreamProducerD3DTexture.cpp: Implements the stream producer for D3D11 textures + +#include "libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h" + +#include "common/utilities.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include <array> + +namespace rx +{ + +namespace +{ + +egl::Error GetGLDescFromTex(ID3D11Texture2D *const tex, + const UINT planeIndex, + egl::Stream::GLTextureDescription *const out) +{ + if (!tex) + return egl::EglBadParameter() << "Texture is null"; + + D3D11_TEXTURE2D_DESC desc; + tex->GetDesc(&desc); + + if (desc.Width < 1 || desc.Height < 1) + return egl::EglBadParameter() << "Width or height < 1"; + + out->width = desc.Width; + out->height = desc.Height; + out->mipLevels = 0; + + std::array<uint32_t, 2> planeFormats = {}; + switch (desc.Format) + { + case DXGI_FORMAT_NV12: + planeFormats = {GL_R8, GL_RG8}; + break; + + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + planeFormats = {GL_R16_EXT, GL_RG16_EXT}; + break; + + case DXGI_FORMAT_R8_UNORM: + planeFormats = {GL_R8}; + break; + case DXGI_FORMAT_R8G8_UNORM: + planeFormats[0] = GL_RG8; + break; + case DXGI_FORMAT_R8G8B8A8_UNORM: + planeFormats[0] = GL_RGBA8; + break; + case DXGI_FORMAT_B8G8R8A8_UNORM: + planeFormats[0] = GL_BGRA8_EXT; + break; + + case DXGI_FORMAT_R16_UNORM: + planeFormats[0] = GL_R16_EXT; + break; + case DXGI_FORMAT_R16G16_UNORM: + planeFormats[0] = GL_RG16_EXT; + break; + case DXGI_FORMAT_R16G16B16A16_UNORM: + planeFormats[0] = GL_RGBA16_EXT; + break; + case DXGI_FORMAT_R16G16B16A16_FLOAT: + planeFormats[0] = GL_RGBA16F; + break; + + default: + return egl::EglBadParameter() << "Unsupported format"; + } + + if (planeFormats[1]) // If we have YUV planes, expect 4:2:0. + { + if ((desc.Width % 2) != 0 || (desc.Height % 2) != 0) + return egl::EglBadParameter() << "YUV 4:2:0 textures must have even width and height."; + } + if (planeIndex > 0) + { + out->width /= 2; + out->height /= 2; + } + + out->internalFormat = 0; + if (planeIndex < planeFormats.size()) + { + out->internalFormat = planeFormats[planeIndex]; + } + if (!out->internalFormat) + return egl::EglBadParameter() << "Plane out of range"; + + return egl::NoError(); +} + +} // namespace + +StreamProducerD3DTexture::StreamProducerD3DTexture(Renderer11 *renderer) + : mRenderer(renderer), mTexture(nullptr), mArraySlice(0), mPlaneOffset(0) +{} + +StreamProducerD3DTexture::~StreamProducerD3DTexture() +{ + SafeRelease(mTexture); +} + +egl::Error StreamProducerD3DTexture::validateD3DTexture(const void *pointer, + const egl::AttributeMap &attributes) const +{ + // We must remove the const qualifier because "GetDevice" and "GetDesc" are non-const in D3D11. + ID3D11Texture2D *textureD3D = static_cast<ID3D11Texture2D *>(const_cast<void *>(pointer)); + + // Check that the texture originated from our device + angle::ComPtr<ID3D11Device> device; + textureD3D->GetDevice(&device); + if (device.Get() != mRenderer->getDevice()) + { + return egl::EglBadParameter() << "Texture not created on ANGLE D3D device"; + } + + const auto planeId = static_cast<UINT>(attributes.get(EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG, 0)); + egl::Stream::GLTextureDescription unused; + return GetGLDescFromTex(textureD3D, planeId, &unused); +} + +void StreamProducerD3DTexture::postD3DTexture(void *pointer, const egl::AttributeMap &attributes) +{ + ASSERT(pointer != nullptr); + ID3D11Texture2D *textureD3D = static_cast<ID3D11Texture2D *>(pointer); + + // Release the previous texture if there is one + SafeRelease(mTexture); + + mTexture = textureD3D; + mTexture->AddRef(); + mPlaneOffset = static_cast<UINT>(attributes.get(EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG, 0)); + mArraySlice = static_cast<UINT>(attributes.get(EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, 0)); +} + +egl::Stream::GLTextureDescription StreamProducerD3DTexture::getGLFrameDescription(int planeIndex) +{ + const auto planeOffsetIndex = static_cast<UINT>(planeIndex + mPlaneOffset); + egl::Stream::GLTextureDescription ret; + ANGLE_SWALLOW_ERR(GetGLDescFromTex(mTexture, planeOffsetIndex, &ret)); + return ret; +} + +ID3D11Texture2D *StreamProducerD3DTexture::getD3DTexture() +{ + return mTexture; +} + +UINT StreamProducerD3DTexture::getArraySlice() +{ + return mArraySlice; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h new file mode 100644 index 0000000000..bcb0057fde --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h @@ -0,0 +1,44 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StreamProducerD3DTexture.h: Interface for a D3D11 texture stream producer + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_STREAM11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_STREAM11_H_ + +#include "libANGLE/renderer/StreamProducerImpl.h" + +namespace rx +{ +class Renderer11; + +class StreamProducerD3DTexture : public StreamProducerImpl +{ + public: + StreamProducerD3DTexture(Renderer11 *renderer); + ~StreamProducerD3DTexture() override; + + egl::Error validateD3DTexture(const void *pointer, + const egl::AttributeMap &attributes) const override; + void postD3DTexture(void *pointer, const egl::AttributeMap &attributes) override; + egl::Stream::GLTextureDescription getGLFrameDescription(int planeIndex) override; + + // Gets a pointer to the internal D3D texture + ID3D11Texture2D *getD3DTexture(); + + // Gets the slice index for the D3D texture that the frame is in + UINT getArraySlice(); + + private: + Renderer11 *mRenderer; + + ID3D11Texture2D *mTexture; + UINT mArraySlice; + UINT mPlaneOffset; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_STREAM11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp new file mode 100644 index 0000000000..8470510ea8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp @@ -0,0 +1,1119 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChain11.cpp: Implements a back-end specific class for the D3D11 swap chain. + +#include "libANGLE/renderer/d3d/d3d11/SwapChain11.h" + +#include <EGL/eglext.h> + +#include "libANGLE/features.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "libANGLE/trace.h" + +// Precompiled shaders +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dms11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvecolor2dps.h" + +#ifdef ANGLE_ENABLE_KEYEDMUTEX +# define ANGLE_RESOURCE_SHARE_TYPE D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX +#else +# define ANGLE_RESOURCE_SHARE_TYPE D3D11_RESOURCE_MISC_SHARED +#endif + +namespace rx +{ + +namespace +{ +// To avoid overflow in QPC to Microseconds calculations, since we multiply +// by kMicrosecondsPerSecond, then the QPC value should not exceed +// (2^63 - 1) / 1E6. If it exceeds that threshold, we divide then multiply. +static constexpr int64_t kQPCOverflowThreshold = 0x8637BD05AF7; +static constexpr int64_t kMicrosecondsPerSecond = 1000000; + +bool NeedsOffscreenTexture(Renderer11 *renderer, NativeWindow11 *nativeWindow, EGLint orientation) +{ + // We don't need an offscreen texture if either orientation = INVERT_Y, + // or present path fast is enabled and we're not rendering onto an offscreen surface. + return orientation != EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE && + !(renderer->presentPathFastEnabled() && nativeWindow->getNativeWindow()); +} +} // anonymous namespace + +SwapChain11::SwapChain11(Renderer11 *renderer, + NativeWindow11 *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) + : SwapChainD3D(shareHandle, d3dTexture, backBufferFormat, depthBufferFormat), + mRenderer(renderer), + mWidth(-1), + mHeight(-1), + mOrientation(orientation), + mAppCreatedShareHandle(mShareHandle != nullptr), + mSwapInterval(0), + mPassThroughResourcesInit(false), + mNativeWindow(nativeWindow), + mFirstSwap(true), + mSwapChain(nullptr), + mSwapChain1(nullptr), + mKeyedMutex(nullptr), + mBackBufferTexture(), + mBackBufferRTView(), + mBackBufferSRView(), + mNeedsOffscreenTexture(NeedsOffscreenTexture(renderer, nativeWindow, orientation)), + mOffscreenTexture(), + mOffscreenRTView(), + mOffscreenSRView(), + mNeedsOffscreenTextureCopy(false), + mOffscreenTextureCopyForSRV(), + mDepthStencilTexture(), + mDepthStencilDSView(), + mDepthStencilSRView(), + mQuadVB(), + mPassThroughSampler(), + mPassThroughIL(), + mPassThroughVS(), + mPassThroughOrResolvePS(), + mPassThroughRS(), + mColorRenderTarget(this, renderer, false), + mDepthStencilRenderTarget(this, renderer, true), + mEGLSamples(samples) +{ + // Check that if present path fast is active then we're using the default orientation + ASSERT(!mRenderer->presentPathFastEnabled() || orientation == 0); + + // Get the performance counter + LARGE_INTEGER counterFreqency = {}; + BOOL success = QueryPerformanceFrequency(&counterFreqency); + ASSERT(success); + + mQPCFrequency = counterFreqency.QuadPart; +} + +SwapChain11::~SwapChain11() +{ + release(); +} + +void SwapChain11::release() +{ + // TODO(jmadill): Should probably signal that the RenderTarget is dirty. + + SafeRelease(mSwapChain1); + SafeRelease(mSwapChain); + SafeRelease(mKeyedMutex); + mBackBufferTexture.reset(); + mBackBufferRTView.reset(); + mBackBufferSRView.reset(); + mOffscreenTexture.reset(); + mOffscreenRTView.reset(); + mOffscreenSRView.reset(); + mDepthStencilTexture.reset(); + mDepthStencilDSView.reset(); + mDepthStencilSRView.reset(); + mQuadVB.reset(); + mPassThroughSampler.reset(); + mPassThroughIL.reset(); + mPassThroughVS.reset(); + mPassThroughOrResolvePS.reset(); + mPassThroughRS.reset(); + + if (!mAppCreatedShareHandle) + { + mShareHandle = nullptr; + } +} + +void SwapChain11::releaseOffscreenColorBuffer() +{ + mOffscreenTexture.reset(); + mOffscreenRTView.reset(); + mOffscreenSRView.reset(); + mNeedsOffscreenTextureCopy = false; + mOffscreenTextureCopyForSRV.reset(); +} + +void SwapChain11::releaseOffscreenDepthBuffer() +{ + mDepthStencilTexture.reset(); + mDepthStencilDSView.reset(); + mDepthStencilSRView.reset(); +} + +EGLint SwapChain11::resetOffscreenBuffers(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight) +{ + if (mNeedsOffscreenTexture) + { + EGLint result = resetOffscreenColorBuffer(displayD3D, backbufferWidth, backbufferHeight); + if (result != EGL_SUCCESS) + { + return result; + } + } + + EGLint result = resetOffscreenDepthBuffer(displayD3D, backbufferWidth, backbufferHeight); + if (result != EGL_SUCCESS) + { + return result; + } + + mWidth = backbufferWidth; + mHeight = backbufferHeight; + + return EGL_SUCCESS; +} + +EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight) +{ + ASSERT(mNeedsOffscreenTexture); + + ANGLE_TRACE_EVENT0("gpu.angle", "SwapChain11::resetOffscreenTexture"); + ID3D11Device *device = mRenderer->getDevice(); + + ASSERT(device != nullptr); + + // D3D11 does not allow zero size textures + ASSERT(backbufferWidth >= 1); + ASSERT(backbufferHeight >= 1); + + // Preserve the render target content + TextureHelper11 previousOffscreenTexture(std::move(mOffscreenTexture)); + const int previousWidth = mWidth; + const int previousHeight = mHeight; + + releaseOffscreenColorBuffer(); + + const d3d11::Format &backbufferFormatInfo = + d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); + D3D11_TEXTURE2D_DESC offscreenTextureDesc = {}; + + // If the app passed in a share handle or D3D texture, open the resource + // See EGL_ANGLE_d3d_share_handle_client_buffer and EGL_ANGLE_d3d_texture_client_buffer + if (mAppCreatedShareHandle || mD3DTexture != nullptr) + { + if (mAppCreatedShareHandle) + { + ID3D11Resource *tempResource11; + HRESULT result = device->OpenSharedResource(mShareHandle, __uuidof(ID3D11Resource), + (void **)&tempResource11); + if (FAILED(result) && mRenderer->getDevice1()) + { + result = mRenderer->getDevice1()->OpenSharedResource1( + mShareHandle, __uuidof(ID3D11Resource), (void **)&tempResource11); + } + + if (FAILED(result)) + { + ERR() << "Could not open shared handle. " << gl::FmtHR(result); + release(); + return EGL_BAD_SURFACE; + } + + mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11), + backbufferFormatInfo); + SafeRelease(tempResource11); + } + else if (mD3DTexture != nullptr) + { + mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(mD3DTexture), + backbufferFormatInfo); + } + else + { + UNREACHABLE(); + } + ASSERT(mOffscreenTexture.valid()); + mOffscreenTexture.getDesc(&offscreenTextureDesc); + + // Fail if the offscreen texture is not renderable. + if ((offscreenTextureDesc.BindFlags & D3D11_BIND_RENDER_TARGET) == 0) + { + ERR() << "Could not use provided offscreen texture, texture not renderable."; + release(); + return EGL_BAD_SURFACE; + } + } + else + { + const bool useSharedResource = + !mNativeWindow->getNativeWindow() && mRenderer->getShareHandleSupport(); + + offscreenTextureDesc.Width = backbufferWidth; + offscreenTextureDesc.Height = backbufferHeight; + offscreenTextureDesc.Format = backbufferFormatInfo.texFormat; + offscreenTextureDesc.MipLevels = 1; + offscreenTextureDesc.ArraySize = 1; + offscreenTextureDesc.SampleDesc.Count = getD3DSamples(); + offscreenTextureDesc.SampleDesc.Quality = 0; + offscreenTextureDesc.Usage = D3D11_USAGE_DEFAULT; + offscreenTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; + offscreenTextureDesc.CPUAccessFlags = 0; + offscreenTextureDesc.MiscFlags = useSharedResource ? ANGLE_RESOURCE_SHARE_TYPE : 0; + + angle::Result result = mRenderer->allocateTexture(displayD3D, offscreenTextureDesc, + backbufferFormatInfo, &mOffscreenTexture); + if (result == angle::Result::Stop) + { + ERR() << "Could not create offscreen texture, " << displayD3D->getStoredErrorString(); + release(); + return EGL_BAD_ALLOC; + } + + mOffscreenTexture.setInternalName("OffscreenBackBufferTexture"); + + // EGL_ANGLE_surface_d3d_texture_2d_share_handle requires that we store a share handle for + // the client + if (useSharedResource) + { + IDXGIResource *offscreenTextureResource = nullptr; + HRESULT hr = mOffscreenTexture.get()->QueryInterface( + __uuidof(IDXGIResource), (void **)&offscreenTextureResource); + + // Fall back to no share handle on failure + if (FAILED(hr)) + { + ERR() << "Could not query offscreen texture resource, " << gl::FmtHR(hr); + } + else + { + hr = offscreenTextureResource->GetSharedHandle(&mShareHandle); + SafeRelease(offscreenTextureResource); + + if (FAILED(hr)) + { + mShareHandle = nullptr; + ERR() << "Could not get offscreen texture shared handle, " << gl::FmtHR(hr); + } + } + } + } + + // This may return null if the original texture was created without a keyed mutex. + mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture.get()); + + D3D11_RENDER_TARGET_VIEW_DESC offscreenRTVDesc; + offscreenRTVDesc.Format = backbufferFormatInfo.rtvFormat; + offscreenRTVDesc.ViewDimension = + (mEGLSamples <= 1) ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS; + offscreenRTVDesc.Texture2D.MipSlice = 0; + + angle::Result result = mRenderer->allocateResource(displayD3D, offscreenRTVDesc, + mOffscreenTexture.get(), &mOffscreenRTView); + if (result == angle::Result::Stop) + { + ERR() << "Could not create offscreen back buffer render target, " + << displayD3D->getStoredErrorString(); + release(); + return EGL_BAD_ALLOC; + } + mOffscreenRTView.setInternalName("OffscreenBackBufferRenderTarget"); + + D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc; + offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat; + offscreenSRVDesc.ViewDimension = + (mEGLSamples <= 1) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS; + offscreenSRVDesc.Texture2D.MostDetailedMip = 0; + offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1); + + if (offscreenTextureDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE) + { + result = mRenderer->allocateResource(displayD3D, offscreenSRVDesc, mOffscreenTexture.get(), + &mOffscreenSRView); + if (result == angle::Result::Stop) + { + ERR() << "Could not create offscreen back buffer shader resource, " + << displayD3D->getStoredErrorString(); + release(); + return EGL_BAD_ALLOC; + } + mOffscreenSRView.setInternalName("OffscreenBackBufferShaderResource"); + } + else + { + // Special case for external textures that cannot support sampling. Since internally we + // assume our SwapChain is always readable, we make a copy texture that is compatible. + mNeedsOffscreenTextureCopy = true; + } + + if (previousOffscreenTexture.valid()) + { + D3D11_BOX sourceBox = {}; + sourceBox.left = 0; + sourceBox.right = std::min(previousWidth, backbufferWidth); + sourceBox.top = std::max(previousHeight - backbufferHeight, 0); + sourceBox.bottom = previousHeight; + sourceBox.front = 0; + sourceBox.back = 1; + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + const int yoffset = std::max(backbufferHeight - previousHeight, 0); + deviceContext->CopySubresourceRegion(mOffscreenTexture.get(), 0, 0, yoffset, 0, + previousOffscreenTexture.get(), 0, &sourceBox); + + if (mSwapChain) + { + swapRect(displayD3D, 0, 0, backbufferWidth, backbufferHeight); + } + } + + return EGL_SUCCESS; +} + +EGLint SwapChain11::resetOffscreenDepthBuffer(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight) +{ + releaseOffscreenDepthBuffer(); + + if (mDepthBufferFormat != GL_NONE) + { + const d3d11::Format &depthBufferFormatInfo = + d3d11::Format::Get(mDepthBufferFormat, mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC depthStencilTextureDesc; + depthStencilTextureDesc.Width = backbufferWidth; + depthStencilTextureDesc.Height = backbufferHeight; + depthStencilTextureDesc.Format = depthBufferFormatInfo.texFormat; + depthStencilTextureDesc.MipLevels = 1; + depthStencilTextureDesc.ArraySize = 1; + depthStencilTextureDesc.SampleDesc.Count = getD3DSamples(); + depthStencilTextureDesc.Usage = D3D11_USAGE_DEFAULT; + depthStencilTextureDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + + // If there is a multisampled offscreen color texture, the offscreen depth-stencil texture + // must also have the same quality value. + if (mOffscreenTexture.valid() && getD3DSamples() > 1) + { + D3D11_TEXTURE2D_DESC offscreenTextureDesc = {}; + mOffscreenTexture.getDesc(&offscreenTextureDesc); + depthStencilTextureDesc.SampleDesc.Quality = offscreenTextureDesc.SampleDesc.Quality; + } + else + { + depthStencilTextureDesc.SampleDesc.Quality = 0; + } + + // Only create an SRV if it is supported + bool depthStencilSRV = + depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN && + (mRenderer->getRenderer11DeviceCaps().supportsMultisampledDepthStencilSRVs || + depthStencilTextureDesc.SampleDesc.Count <= 1); + if (depthStencilSRV) + { + depthStencilTextureDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE; + } + + depthStencilTextureDesc.CPUAccessFlags = 0; + depthStencilTextureDesc.MiscFlags = 0; + + angle::Result result = mRenderer->allocateTexture( + displayD3D, depthStencilTextureDesc, depthBufferFormatInfo, &mDepthStencilTexture); + if (result == angle::Result::Stop) + { + ERR() << "Could not create depthstencil surface for new swap chain, " + << displayD3D->getStoredErrorString(); + release(); + return EGL_BAD_ALLOC; + } + mDepthStencilTexture.setInternalName("OffscreenDepthStencilTexture"); + + D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilDesc; + depthStencilDesc.Format = depthBufferFormatInfo.dsvFormat; + depthStencilDesc.ViewDimension = + (mEGLSamples <= 1) ? D3D11_DSV_DIMENSION_TEXTURE2D : D3D11_DSV_DIMENSION_TEXTURE2DMS; + depthStencilDesc.Flags = 0; + depthStencilDesc.Texture2D.MipSlice = 0; + + result = mRenderer->allocateResource(displayD3D, depthStencilDesc, + mDepthStencilTexture.get(), &mDepthStencilDSView); + ASSERT(result != angle::Result::Stop); + mDepthStencilDSView.setInternalName("OffscreenDSV"); + + if (depthStencilSRV) + { + D3D11_SHADER_RESOURCE_VIEW_DESC depthStencilSRVDesc; + depthStencilSRVDesc.Format = depthBufferFormatInfo.srvFormat; + depthStencilSRVDesc.ViewDimension = (mEGLSamples <= 1) + ? D3D11_SRV_DIMENSION_TEXTURE2D + : D3D11_SRV_DIMENSION_TEXTURE2DMS; + depthStencilSRVDesc.Texture2D.MostDetailedMip = 0; + depthStencilSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1); + + result = mRenderer->allocateResource(displayD3D, depthStencilSRVDesc, + mDepthStencilTexture.get(), &mDepthStencilSRView); + ASSERT(result != angle::Result::Stop); + mDepthStencilSRView.setInternalName("OffscreenDepthStencilSRV"); + } + } + + return EGL_SUCCESS; +} + +EGLint SwapChain11::resize(DisplayD3D *displayD3D, EGLint backbufferWidth, EGLint backbufferHeight) +{ + ANGLE_TRACE_EVENT0("gpu.angle", "SwapChain11::resize"); + ID3D11Device *device = mRenderer->getDevice(); + + if (device == nullptr) + { + return EGL_BAD_ACCESS; + } + + // EGL allows creating a surface with 0x0 dimension, however, DXGI does not like 0x0 swapchains + if (backbufferWidth < 1 || backbufferHeight < 1) + { + return EGL_SUCCESS; + } + + // Don't resize unnecessarily + if (mWidth == backbufferWidth && mHeight == backbufferHeight) + { + return EGL_SUCCESS; + } + + // Can only call resize if we have already created our swap buffer and resources + ASSERT(mSwapChain && mBackBufferTexture.valid() && mBackBufferRTView.valid() && + mBackBufferSRView.valid()); + + mBackBufferTexture.reset(); + mBackBufferRTView.reset(); + mBackBufferSRView.reset(); + + // Resize swap chain + DXGI_SWAP_CHAIN_DESC desc; + HRESULT hr = mSwapChain->GetDesc(&desc); + if (FAILED(hr)) + { + ERR() << "Error reading swap chain description, " << gl::FmtHR(hr); + release(); + return EGL_BAD_ALLOC; + } + + hr = mSwapChain->ResizeBuffers(desc.BufferCount, backbufferWidth, backbufferHeight, + getSwapChainNativeFormat(), 0); + + if (FAILED(hr)) + { + ERR() << "Error resizing swap chain buffers, " << gl::FmtHR(hr); + release(); + + if (d3d11::isDeviceLostError(hr)) + { + HRESULT reason = device->GetDeviceRemovedReason(); + ERR() << "Device lost in SwapChain11::resize " << gl::FmtHR(hr) + << ", reason: " << gl::FmtHR(reason); + return EGL_CONTEXT_LOST; + } + else + { + return EGL_BAD_ALLOC; + } + } + + ID3D11Texture2D *backbufferTexture = nullptr; + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), + reinterpret_cast<void **>(&backbufferTexture)); + ASSERT(SUCCEEDED(hr)); + if (SUCCEEDED(hr)) + { + const auto &format = + d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); + mBackBufferTexture.set(backbufferTexture, format); + mBackBufferTexture.setInternalName("BackBufferTexture"); + + angle::Result result = mRenderer->allocateResourceNoDesc( + displayD3D, mBackBufferTexture.get(), &mBackBufferRTView); + ASSERT(result != angle::Result::Stop); + mBackBufferRTView.setInternalName("BackBufferRTV"); + + result = mRenderer->allocateResourceNoDesc(displayD3D, mBackBufferTexture.get(), + &mBackBufferSRView); + ASSERT(result != angle::Result::Stop); + mBackBufferSRView.setInternalName("BackBufferSRV"); + } + + mFirstSwap = true; + + return resetOffscreenBuffers(displayD3D, backbufferWidth, backbufferHeight); +} + +DXGI_FORMAT SwapChain11::getSwapChainNativeFormat() const +{ + // Return a render target format for offscreen rendering is supported by IDXGISwapChain. + // MSDN https://msdn.microsoft.com/en-us/library/windows/desktop/bb173064(v=vs.85).aspx + switch (mOffscreenRenderTargetFormat) + { + case GL_RGBA8: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_RGB8: + case GL_RGB565: + return DXGI_FORMAT_R8G8B8A8_UNORM; + + case GL_BGRA8_EXT: + return DXGI_FORMAT_B8G8R8A8_UNORM; + + case GL_RGB10_A2: + return DXGI_FORMAT_R10G10B10A2_UNORM; + + case GL_RGBA16F: + return DXGI_FORMAT_R16G16B16A16_FLOAT; + + default: + UNREACHABLE(); + return DXGI_FORMAT_UNKNOWN; + } +} + +EGLint SwapChain11::reset(DisplayD3D *displayD3D, + EGLint backbufferWidth, + EGLint backbufferHeight, + EGLint swapInterval) +{ + mSwapInterval = static_cast<unsigned int>(swapInterval); + if (mSwapInterval > 4) + { + // IDXGISwapChain::Present documentation states that valid sync intervals are in the [0,4] + // range + return EGL_BAD_PARAMETER; + } + + // If the swap chain already exists, just resize + if (mSwapChain != nullptr) + { + return resize(displayD3D, backbufferWidth, backbufferHeight); + } + + ANGLE_TRACE_EVENT0("gpu.angle", "SwapChain11::reset"); + ID3D11Device *device = mRenderer->getDevice(); + + if (device == nullptr) + { + return EGL_BAD_ACCESS; + } + + // Release specific resources to free up memory for the new render target, while the + // old render target still exists for the purpose of preserving its contents. + SafeRelease(mSwapChain1); + SafeRelease(mSwapChain); + mBackBufferTexture.reset(); + mBackBufferRTView.reset(); + + // EGL allows creating a surface with 0x0 dimension, however, DXGI does not like 0x0 swapchains + if (backbufferWidth < 1 || backbufferHeight < 1) + { + releaseOffscreenColorBuffer(); + return EGL_SUCCESS; + } + + if (mNativeWindow->getNativeWindow()) + { + HRESULT hr = mNativeWindow->createSwapChain( + device, mRenderer->getDxgiFactory(), getSwapChainNativeFormat(), backbufferWidth, + backbufferHeight, mNeedsOffscreenTexture ? 1 : getD3DSamples(), &mSwapChain); + + if (FAILED(hr)) + { + ERR() << "Could not create additional swap chains or offscreen surfaces, " + << gl::FmtHR(hr); + release(); + + if (d3d11::isDeviceLostError(hr)) + { + HRESULT reason = device->GetDeviceRemovedReason(); + ERR() << "Device lost in SwapChain11::reset " << gl::FmtHR(hr) + << ", reason: " << gl::FmtHR(reason); + return EGL_CONTEXT_LOST; + } + else + { + return EGL_BAD_ALLOC; + } + } + + if (mRenderer->getRenderer11DeviceCaps().supportsDXGI1_2) + { + mSwapChain1 = d3d11::DynamicCastComObject<IDXGISwapChain1>(mSwapChain); + } + + ID3D11Texture2D *backbufferTex = nullptr; + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), + reinterpret_cast<LPVOID *>(&backbufferTex)); + ASSERT(SUCCEEDED(hr)); + const auto &format = + d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); + mBackBufferTexture.set(backbufferTex, format); + mBackBufferTexture.setInternalName("BackBufferTexture"); + + angle::Result result = mRenderer->allocateResourceNoDesc( + displayD3D, mBackBufferTexture.get(), &mBackBufferRTView); + ASSERT(result != angle::Result::Stop); + mBackBufferRTView.setInternalName("BackBufferRTV"); + + result = mRenderer->allocateResourceNoDesc(displayD3D, mBackBufferTexture.get(), + &mBackBufferSRView); + ASSERT(result != angle::Result::Stop); + mBackBufferSRView.setInternalName("BackBufferSRV"); + } + + mFirstSwap = true; + + return resetOffscreenBuffers(displayD3D, backbufferWidth, backbufferHeight); +} + +angle::Result SwapChain11::initPassThroughResources(DisplayD3D *displayD3D) +{ + if (mPassThroughResourcesInit) + { + return angle::Result::Continue; + } + + ANGLE_TRACE_EVENT0("gpu.angle", "SwapChain11::initPassThroughResources"); + ID3D11Device *device = mRenderer->getDevice(); + + ASSERT(device != nullptr); + + // Make sure our resources are all not allocated, when we create + ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid()); + ASSERT(!mPassThroughIL.valid() && !mPassThroughVS.valid() && !mPassThroughOrResolvePS.valid()); + + D3D11_BUFFER_DESC vbDesc; + vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4; + vbDesc.Usage = D3D11_USAGE_DYNAMIC; + vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + vbDesc.MiscFlags = 0; + vbDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(displayD3D, vbDesc, &mQuadVB)); + mQuadVB.setInternalName("SwapChainQuadVB"); + + D3D11_SAMPLER_DESC samplerDesc; + samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; + samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; + samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; + samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; + samplerDesc.MipLODBias = 0.0f; + samplerDesc.MaxAnisotropy = 0; + samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; + samplerDesc.BorderColor[0] = 0.0f; + samplerDesc.BorderColor[1] = 0.0f; + samplerDesc.BorderColor[2] = 0.0f; + samplerDesc.BorderColor[3] = 0.0f; + samplerDesc.MinLOD = 0; + samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; + + ANGLE_TRY(mRenderer->allocateResource(displayD3D, samplerDesc, &mPassThroughSampler)); + mPassThroughSampler.setInternalName("SwapChainPassThroughSampler"); + + D3D11_INPUT_ELEMENT_DESC quadLayout[] = { + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }; + + InputElementArray quadElements(quadLayout); + ShaderData vertexShaderData(g_VS_Passthrough2D); + + ANGLE_TRY( + mRenderer->allocateResource(displayD3D, quadElements, &vertexShaderData, &mPassThroughIL)); + mPassThroughIL.setInternalName("SwapChainPassThroughIL"); + + ANGLE_TRY(mRenderer->allocateResource(displayD3D, vertexShaderData, &mPassThroughVS)); + mPassThroughVS.setInternalName("SwapChainPassThroughVS"); + + if (mEGLSamples <= 1) + { + ShaderData pixelShaderData(g_PS_PassthroughRGBA2D); + ANGLE_TRY( + mRenderer->allocateResource(displayD3D, pixelShaderData, &mPassThroughOrResolvePS)); + } + else + { + if (mNativeWindow->getNativeWindow() && mNeedsOffscreenTexture) + { + ShaderData pixelShaderData(g_PS_ResolveColor2D); + ANGLE_TRY( + mRenderer->allocateResource(displayD3D, pixelShaderData, &mPassThroughOrResolvePS)); + } + else + { + ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS); + ANGLE_TRY( + mRenderer->allocateResource(displayD3D, pixelShaderData, &mPassThroughOrResolvePS)); + } + } + + mPassThroughOrResolvePS.setInternalName("SwapChainPassThroughPS"); + + // Use the default rasterizer state but without culling + D3D11_RASTERIZER_DESC rasterizerDesc; + rasterizerDesc.FillMode = D3D11_FILL_SOLID; + rasterizerDesc.CullMode = D3D11_CULL_NONE; + rasterizerDesc.FrontCounterClockwise = FALSE; + rasterizerDesc.DepthBias = 0; + rasterizerDesc.SlopeScaledDepthBias = 0.0f; + rasterizerDesc.DepthBiasClamp = 0.0f; + rasterizerDesc.DepthClipEnable = TRUE; + rasterizerDesc.ScissorEnable = FALSE; + rasterizerDesc.MultisampleEnable = FALSE; + rasterizerDesc.AntialiasedLineEnable = FALSE; + + ANGLE_TRY(mRenderer->allocateResource(displayD3D, rasterizerDesc, &mPassThroughRS)); + mPassThroughRS.setInternalName("SwapChainPassThroughRasterizerState"); + + mPassThroughResourcesInit = true; + return angle::Result::Continue; +} + +// parameters should be validated/clamped by caller +EGLint SwapChain11::swapRect(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + if (mNeedsOffscreenTexture) + { + EGLint result = copyOffscreenToBackbuffer(displayD3D, x, y, width, height); + if (result != EGL_SUCCESS) + { + return result; + } + } + + EGLint result = present(displayD3D, x, y, width, height); + if (result != EGL_SUCCESS) + { + return result; + } + + mRenderer->onSwap(); + + return EGL_SUCCESS; +} + +EGLint SwapChain11::copyOffscreenToBackbuffer(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + if (!mSwapChain) + { + return EGL_SUCCESS; + } + + if (initPassThroughResources(displayD3D) == angle::Result::Stop) + { + return EGL_BAD_ALLOC; + } + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // Set vertices + D3D11_MAPPED_SUBRESOURCE mappedResource; + HRESULT result = + deviceContext->Map(mQuadVB.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + if (FAILED(result)) + { + return EGL_BAD_ACCESS; + } + + d3d11::PositionTexCoordVertex *vertices = + static_cast<d3d11::PositionTexCoordVertex *>(mappedResource.pData); + + // Create a quad in homogeneous coordinates + float x1 = (x / float(mWidth)) * 2.0f - 1.0f; + float y1 = (y / float(mHeight)) * 2.0f - 1.0f; + float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f; + float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f; + + float u1 = x / float(mWidth); + float v1 = y / float(mHeight); + float u2 = (x + width) / float(mWidth); + float v2 = (y + height) / float(mHeight); + + // Invert the quad vertices depending on the surface orientation. + if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE) != 0) + { + std::swap(x1, x2); + } + if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE) != 0) + { + std::swap(y1, y2); + } + + d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v1); + d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v2); + d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1); + d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2); + + deviceContext->Unmap(mQuadVB.get(), 0); + + StateManager11 *stateManager = mRenderer->getStateManager(); + + constexpr UINT stride = sizeof(d3d11::PositionTexCoordVertex); + stateManager->setSingleVertexBuffer(&mQuadVB, stride, 0); + + // Apply state + stateManager->setDepthStencilState(nullptr, 0xFFFFFFFF); + stateManager->setSimpleBlendState(nullptr); + stateManager->setRasterizerState(&mPassThroughRS); + + // Apply shaders + stateManager->setInputLayout(&mPassThroughIL); + stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + stateManager->setDrawShaders(&mPassThroughVS, nullptr, &mPassThroughOrResolvePS); + + // Apply render targets. Use the proxy context in display. + stateManager->setRenderTarget(mBackBufferRTView.get(), nullptr); + + // Set the viewport + stateManager->setSimpleViewport(mWidth, mHeight); + + // Apply textures + stateManager->setSimplePixelTextureAndSampler(mOffscreenSRView, mPassThroughSampler); + + // Draw + deviceContext->Draw(4, 0); + + return EGL_SUCCESS; +} + +EGLint SwapChain11::present(DisplayD3D *displayD3D, EGLint x, EGLint y, EGLint width, EGLint height) +{ + if (!mSwapChain) + { + return EGL_SUCCESS; + } + + UINT swapInterval = mSwapInterval; +#if ANGLE_VSYNC == ANGLE_DISABLED + swapInterval = 0; +#endif + + HRESULT result = S_OK; + + // Use IDXGISwapChain1::Present1 with a dirty rect if DXGI 1.2 is available. + // Dirty rect present is not supported with a multisampled swapchain. + if (mSwapChain1 != nullptr && mEGLSamples <= 1) + { + if (mFirstSwap) + { + // Can't swap with a dirty rect if this swap chain has never swapped before + DXGI_PRESENT_PARAMETERS params = {0, nullptr, nullptr, nullptr}; + result = mSwapChain1->Present1(swapInterval, 0, ¶ms); + } + else + { + RECT rect = {static_cast<LONG>(x), static_cast<LONG>(mHeight - y - height), + static_cast<LONG>(x + width), static_cast<LONG>(mHeight - y)}; + DXGI_PRESENT_PARAMETERS params = {1, &rect, nullptr, nullptr}; + result = mSwapChain1->Present1(swapInterval, 0, ¶ms); + } + } + else + { + result = mSwapChain->Present(swapInterval, 0); + } + + mFirstSwap = false; + + // Some swapping mechanisms such as DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL unbind the current render + // target. Mark it dirty. Use the proxy context in display since there is none available. + mRenderer->getStateManager()->invalidateRenderTarget(); + + if (result == DXGI_ERROR_DEVICE_REMOVED) + { + ERR() << "Present failed: the D3D11 device was removed, " + << gl::FmtHR(mRenderer->getDevice()->GetDeviceRemovedReason()); + return EGL_CONTEXT_LOST; + } + else if (result == DXGI_ERROR_DEVICE_RESET) + { + ERR() << "Present failed: the D3D11 device was reset from a bad command."; + return EGL_CONTEXT_LOST; + } + else if (FAILED(result)) + { + ERR() << "Present failed with " << gl::FmtHR(result); + } + + mNativeWindow->commitChange(); + + return EGL_SUCCESS; +} + +const TextureHelper11 &SwapChain11::getOffscreenTexture() +{ + return mNeedsOffscreenTexture ? mOffscreenTexture : mBackBufferTexture; +} + +const d3d11::RenderTargetView &SwapChain11::getRenderTarget() +{ + return mNeedsOffscreenTexture ? mOffscreenRTView : mBackBufferRTView; +} + +angle::Result SwapChain11::getRenderTargetShaderResource(d3d::Context *context, + const d3d11::SharedSRV **outSRV) +{ + *outSRV = nullptr; + + if (!mNeedsOffscreenTexture) + { + ASSERT(mBackBufferSRView.valid()); + *outSRV = &mBackBufferSRView; + return angle::Result::Continue; + } + + if (!mNeedsOffscreenTextureCopy) + { + ASSERT(mOffscreenSRView.valid()); + *outSRV = &mOffscreenSRView; + return angle::Result::Continue; + } + + if (!mOffscreenTextureCopyForSRV.valid()) + { + const d3d11::Format &backbufferFormatInfo = + d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC offscreenCopyDesc; + mOffscreenTexture.getDesc(&offscreenCopyDesc); + + offscreenCopyDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + offscreenCopyDesc.MiscFlags = 0; + offscreenCopyDesc.CPUAccessFlags = 0; + TextureHelper11 offscreenTextureCopyForSRV; + ANGLE_TRY(mRenderer->allocateTexture(context, offscreenCopyDesc, backbufferFormatInfo, + &offscreenTextureCopyForSRV)); + offscreenTextureCopyForSRV.setInternalName("OffscreenBackBufferCopyForSRV"); + + D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc; + offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat; + offscreenSRVDesc.ViewDimension = + (mEGLSamples <= 1) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS; + offscreenSRVDesc.Texture2D.MostDetailedMip = 0; + offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1); + + d3d11::SharedSRV offscreenSRView; + ANGLE_TRY(mRenderer->allocateResource(context, offscreenSRVDesc, + offscreenTextureCopyForSRV.get(), &offscreenSRView)); + offscreenSRView.setInternalName("OffscreenBackBufferSRV"); + + // Commit created objects in one step so we don't end up with half baked member variables. + mOffscreenTextureCopyForSRV = std::move(offscreenTextureCopyForSRV); + mOffscreenSRView = std::move(offscreenSRView); + } + + // Need to copy the offscreen texture into the shader-readable copy, since it's external and + // we don't know if the copy is up-to-date. This works around the problem we have when the app + // passes in a texture that isn't shader-readable. + mRenderer->getDeviceContext()->CopyResource(mOffscreenTextureCopyForSRV.get(), + mOffscreenTexture.get()); + *outSRV = &mOffscreenSRView; + return angle::Result::Continue; +} + +const d3d11::DepthStencilView &SwapChain11::getDepthStencil() +{ + return mDepthStencilDSView; +} + +const d3d11::SharedSRV &SwapChain11::getDepthStencilShaderResource() +{ + return mDepthStencilSRView; +} + +const TextureHelper11 &SwapChain11::getDepthStencilTexture() +{ + return mDepthStencilTexture; +} + +void *SwapChain11::getKeyedMutex() +{ + return mKeyedMutex; +} + +void SwapChain11::recreate() +{ + // possibly should use this method instead of reset +} + +RenderTargetD3D *SwapChain11::getColorRenderTarget() +{ + return &mColorRenderTarget; +} + +RenderTargetD3D *SwapChain11::getDepthStencilRenderTarget() +{ + return &mDepthStencilRenderTarget; +} + +egl::Error SwapChain11::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) +{ + if (!mSwapChain) + { + return egl::EglNotInitialized() << "Swap chain uninitialized"; + } + + DXGI_FRAME_STATISTICS stats = {}; + HRESULT result = mSwapChain->GetFrameStatistics(&stats); + + if (FAILED(result)) + { + return egl::EglBadAlloc() << "Failed to get frame statistics, " << gl::FmtHR(result); + } + + // Conversion from DXGI_FRAME_STATISTICS to the output values: + // stats.SyncRefreshCount -> msc + // stats.PresentCount -> sbc + // stats.SyncQPCTime -> ust with conversion to microseconds via QueryPerformanceFrequency + *msc = stats.SyncRefreshCount; + *sbc = stats.PresentCount; + + LONGLONG syncQPCValue = stats.SyncQPCTime.QuadPart; + // If the QPC Value is below the overflow threshold, we proceed with + // simple multiply and divide. + if (syncQPCValue < kQPCOverflowThreshold) + { + *ust = syncQPCValue * kMicrosecondsPerSecond / mQPCFrequency; + } + else + { + // Otherwise, calculate microseconds in a round about manner to avoid + // overflow and precision issues. + int64_t wholeSeconds = syncQPCValue / mQPCFrequency; + int64_t leftoverTicks = syncQPCValue - (wholeSeconds * mQPCFrequency); + *ust = wholeSeconds * kMicrosecondsPerSecond + + leftoverTicks * kMicrosecondsPerSecond / mQPCFrequency; + } + + return egl::NoError(); +} + +UINT SwapChain11::getD3DSamples() const +{ + return (mEGLSamples == 0) ? 1 : mEGLSamples; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h new file mode 100644 index 0000000000..2d7f0a00ee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h @@ -0,0 +1,134 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChain11.h: Defines a back-end specific class for the D3D11 swap chain. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_ + +#include "common/angleutils.h" +#include "libANGLE/renderer/d3d/SwapChainD3D.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" + +namespace rx +{ +class Renderer11; +class NativeWindow11; + +class SwapChain11 final : public SwapChainD3D +{ + public: + SwapChain11(Renderer11 *renderer, + NativeWindow11 *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples); + ~SwapChain11() override; + + EGLint resize(DisplayD3D *displayD3D, EGLint backbufferWidth, EGLint backbufferHeight) override; + EGLint reset(DisplayD3D *displayD3D, + EGLint backbufferWidth, + EGLint backbufferHeight, + EGLint swapInterval) override; + EGLint swapRect(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) override; + void recreate() override; + + RenderTargetD3D *getColorRenderTarget() override; + RenderTargetD3D *getDepthStencilRenderTarget() override; + + const TextureHelper11 &getOffscreenTexture(); + const d3d11::RenderTargetView &getRenderTarget(); + angle::Result getRenderTargetShaderResource(d3d::Context *context, + const d3d11::SharedSRV **outSRV); + + const TextureHelper11 &getDepthStencilTexture(); + const d3d11::DepthStencilView &getDepthStencil(); + const d3d11::SharedSRV &getDepthStencilShaderResource(); + + EGLint getWidth() const { return mWidth; } + EGLint getHeight() const { return mHeight; } + void *getKeyedMutex() override; + EGLint getSamples() const { return mEGLSamples; } + + egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override; + + private: + void release(); + angle::Result initPassThroughResources(DisplayD3D *displayD3D); + + void releaseOffscreenColorBuffer(); + void releaseOffscreenDepthBuffer(); + EGLint resetOffscreenBuffers(DisplayD3D *displayD3D, int backbufferWidth, int backbufferHeight); + EGLint resetOffscreenColorBuffer(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight); + EGLint resetOffscreenDepthBuffer(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight); + + DXGI_FORMAT getSwapChainNativeFormat() const; + + EGLint copyOffscreenToBackbuffer(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height); + EGLint present(DisplayD3D *displayD3D, EGLint x, EGLint y, EGLint width, EGLint height); + UINT getD3DSamples() const; + + Renderer11 *mRenderer; + EGLint mWidth; + EGLint mHeight; + const EGLint mOrientation; + bool mAppCreatedShareHandle; + unsigned int mSwapInterval; + bool mPassThroughResourcesInit; + + NativeWindow11 *mNativeWindow; // Handler for the Window that the surface is created for. + + bool mFirstSwap; + IDXGISwapChain *mSwapChain; + IDXGISwapChain1 *mSwapChain1; + IDXGIKeyedMutex *mKeyedMutex; + + TextureHelper11 mBackBufferTexture; + d3d11::RenderTargetView mBackBufferRTView; + d3d11::SharedSRV mBackBufferSRView; + + const bool mNeedsOffscreenTexture; + TextureHelper11 mOffscreenTexture; + d3d11::RenderTargetView mOffscreenRTView; + d3d11::SharedSRV mOffscreenSRView; + bool mNeedsOffscreenTextureCopy; + TextureHelper11 mOffscreenTextureCopyForSRV; + + TextureHelper11 mDepthStencilTexture; + d3d11::DepthStencilView mDepthStencilDSView; + d3d11::SharedSRV mDepthStencilSRView; + + d3d11::Buffer mQuadVB; + d3d11::SamplerState mPassThroughSampler; + d3d11::InputLayout mPassThroughIL; + d3d11::VertexShader mPassThroughVS; + d3d11::PixelShader mPassThroughOrResolvePS; + d3d11::RasterizerState mPassThroughRS; + + SurfaceRenderTarget11 mColorRenderTarget; + SurfaceRenderTarget11 mDepthStencilRenderTarget; + + EGLint mEGLSamples; + LONGLONG mQPCFrequency; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp new file mode 100644 index 0000000000..f1277462a9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp @@ -0,0 +1,4352 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureStorage11.cpp: Implements the abstract rx::TextureStorage11 class and its concrete derived +// classes TextureStorage11_2D and TextureStorage11_Cube, which act as the interface to the D3D11 +// texture. + +#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" + +#include <tuple> + +#include "common/MemoryBuffer.h" +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/ImageIndex.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/EGLImageD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Blit11.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Image11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/StreamProducerD3DTexture.h" +#include "libANGLE/renderer/d3d/d3d11/SwapChain11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace rx +{ +TextureStorage11::SamplerKey::SamplerKey() + : baseLevel(0), mipLevels(0), swizzle(false), dropStencil(false) +{} + +TextureStorage11::SamplerKey::SamplerKey(int baseLevel, + int mipLevels, + bool swizzle, + bool dropStencil) + : baseLevel(baseLevel), mipLevels(mipLevels), swizzle(swizzle), dropStencil(dropStencil) +{} + +bool TextureStorage11::SamplerKey::operator<(const SamplerKey &rhs) const +{ + return std::tie(baseLevel, mipLevels, swizzle, dropStencil) < + std::tie(rhs.baseLevel, rhs.mipLevels, rhs.swizzle, rhs.dropStencil); +} + +TextureStorage11::ImageKey::ImageKey() + : level(0), layered(false), layer(0), access(GL_READ_ONLY), format(GL_R32UI) +{} + +TextureStorage11::ImageKey::ImageKey(int level, + bool layered, + int layer, + GLenum access, + GLenum format) + : level(level), layered(layered), layer(layer), access(access), format(format) +{} + +bool TextureStorage11::ImageKey::operator<(const ImageKey &rhs) const +{ + return std::tie(level, layered, layer, access, format) < + std::tie(rhs.level, rhs.layered, rhs.layer, rhs.access, rhs.format); +} + +MultisampledRenderToTextureInfo::MultisampledRenderToTextureInfo(const GLsizei samples, + const gl::ImageIndex &indexSS, + const gl::ImageIndex &indexMS) + : samples(samples), indexSS(indexSS), indexMS(indexMS), msTextureNeedsResolve(false) +{} + +MultisampledRenderToTextureInfo::~MultisampledRenderToTextureInfo() {} + +TextureStorage11::TextureStorage11(Renderer11 *renderer, + UINT bindFlags, + UINT miscFlags, + GLenum internalFormat, + const std::string &label) + : TextureStorage(label), + mRenderer(renderer), + mTopLevel(0), + mMipLevels(0), + mFormatInfo(d3d11::Format::Get(internalFormat, mRenderer->getRenderer11DeviceCaps())), + mTextureWidth(0), + mTextureHeight(0), + mTextureDepth(0), + mDropStencilTexture(), + mBindFlags(bindFlags), + mMiscFlags(miscFlags) +{} + +TextureStorage11::~TextureStorage11() +{ + mSrvCacheForSampler.clear(); +} + +DWORD TextureStorage11::GetTextureBindFlags(GLenum internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + BindFlags flags) +{ + UINT bindFlags = 0; + + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); + if (formatInfo.srvFormat != DXGI_FORMAT_UNKNOWN) + { + bindFlags |= D3D11_BIND_SHADER_RESOURCE; + } + if (formatInfo.uavFormat != DXGI_FORMAT_UNKNOWN && flags.unorderedAccess) + { + bindFlags |= D3D11_BIND_UNORDERED_ACCESS; + } + if (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) + { + bindFlags |= D3D11_BIND_DEPTH_STENCIL; + } + if (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN && flags.renderTarget) + { + bindFlags |= D3D11_BIND_RENDER_TARGET; + } + + return bindFlags; +} + +DWORD TextureStorage11::GetTextureMiscFlags(GLenum internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + BindFlags bindFlags, + int levels) +{ + UINT miscFlags = 0; + + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); + if (bindFlags.renderTarget) + { + if (d3d11::SupportsMipGen(formatInfo.texFormat, renderer11DeviceCaps.featureLevel)) + { + miscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS; + } + } + + return miscFlags; +} + +UINT TextureStorage11::getBindFlags() const +{ + return mBindFlags; +} + +UINT TextureStorage11::getMiscFlags() const +{ + return mMiscFlags; +} + +int TextureStorage11::getTopLevel() const +{ + // Applying top level is meant to be encapsulated inside TextureStorage11. + UNREACHABLE(); + return mTopLevel; +} + +bool TextureStorage11::isRenderTarget() const +{ + return (mBindFlags & (D3D11_BIND_RENDER_TARGET | D3D11_BIND_DEPTH_STENCIL)) != 0; +} + +bool TextureStorage11::isManaged() const +{ + return false; +} + +bool TextureStorage11::supportsNativeMipmapFunction() const +{ + return (mMiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS) != 0; +} + +int TextureStorage11::getLevelCount() const +{ + return mMipLevels - mTopLevel; +} + +int TextureStorage11::getLevelWidth(int mipLevel) const +{ + return std::max(static_cast<int>(mTextureWidth) >> mipLevel, 1); +} + +int TextureStorage11::getLevelHeight(int mipLevel) const +{ + return std::max(static_cast<int>(mTextureHeight) >> mipLevel, 1); +} + +int TextureStorage11::getLevelDepth(int mipLevel) const +{ + return std::max(static_cast<int>(mTextureDepth) >> mipLevel, 1); +} + +angle::Result TextureStorage11::getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + return getResource(context, outResource); +} + +angle::Result TextureStorage11::getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const +{ + UINT mipSlice = static_cast<UINT>(index.getLevelIndex() + mTopLevel); + UINT arraySlice = static_cast<UINT>(index.hasLayer() ? index.getLayerIndex() : 0); + UINT subresource = D3D11CalcSubresource(mipSlice, arraySlice, mMipLevels); + ASSERT(subresource != std::numeric_limits<UINT>::max()); + *outSubresourceIndex = subresource; + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getSRVForSampler(const gl::Context *context, + const gl::TextureState &textureState, + const gl::SamplerState &sampler, + const d3d11::SharedSRV **outSRV) +{ + ANGLE_TRY(resolveTexture(context)); + // Make sure to add the level offset for our tiny compressed texture workaround + const GLuint effectiveBaseLevel = textureState.getEffectiveBaseLevel(); + const bool swizzleRequired = SwizzleRequired(textureState); + const bool mipmapping = gl::IsMipmapFiltered(sampler.getMinFilter()); + unsigned int mipLevels = + mipmapping ? (textureState.getEffectiveMaxLevel() - effectiveBaseLevel + 1) : 1; + + // Make sure there's 'mipLevels' mipmap levels below the base level (offset by the top level, + // which corresponds to GL level 0) + mipLevels = std::min(mipLevels, mMipLevels - mTopLevel - effectiveBaseLevel); + + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + ASSERT(!swizzleRequired); + ASSERT(mipLevels == 1 || mipLevels == mMipLevels); + } + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // We must ensure that the level zero texture is in sync with mipped texture. + ANGLE_TRY(useLevelZeroWorkaroundTexture(context, mipLevels == 1)); + } + + if (swizzleRequired) + { + verifySwizzleExists(GetEffectiveSwizzle(textureState)); + } + + // We drop the stencil when sampling from the SRV if three conditions hold: + // 1. the drop stencil workaround is enabled. + const bool emulateTinyStencilTextures = + mRenderer->getFeatures().emulateTinyStencilTextures.enabled; + // 2. this is a stencil texture. + const bool hasStencil = (mFormatInfo.format().stencilBits > 0); + // 3. the texture has a 1x1 or 2x2 mip. + const int effectiveTopLevel = effectiveBaseLevel + mipLevels - 1; + const bool hasSmallMips = + (getLevelWidth(effectiveTopLevel) <= 2 || getLevelHeight(effectiveTopLevel) <= 2); + + const bool useDropStencil = (emulateTinyStencilTextures && hasStencil && hasSmallMips); + const SamplerKey key(effectiveBaseLevel, mipLevels, swizzleRequired, useDropStencil); + if (useDropStencil) + { + // Ensure drop texture gets created. + DropStencil result = DropStencil::CREATED; + ANGLE_TRY(ensureDropStencilTexture(context, &result)); + + // Clear the SRV cache if necessary. + // TODO(jmadill): Re-use find query result. + const auto srvEntry = mSrvCacheForSampler.find(key); + if (result == DropStencil::CREATED && srvEntry != mSrvCacheForSampler.end()) + { + mSrvCacheForSampler.erase(key); + } + } + + ANGLE_TRY(getCachedOrCreateSRVForSampler(context, key, outSRV)); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getCachedOrCreateSRVForSampler(const gl::Context *context, + const SamplerKey &key, + const d3d11::SharedSRV **outSRV) +{ + auto iter = mSrvCacheForSampler.find(key); + if (iter != mSrvCacheForSampler.end()) + { + *outSRV = &iter->second; + return angle::Result::Continue; + } + + const TextureHelper11 *texture = nullptr; + DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN; + + if (key.swizzle) + { + const auto &swizzleFormat = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + ASSERT(!key.dropStencil || swizzleFormat.format().stencilBits == 0); + ANGLE_TRY(getSwizzleTexture(context, &texture)); + format = swizzleFormat.srvFormat; + } + else if (key.dropStencil) + { + ASSERT(mDropStencilTexture.valid()); + texture = &mDropStencilTexture; + format = DXGI_FORMAT_R32_FLOAT; + } + else + { + ANGLE_TRY(getResource(context, &texture)); + format = mFormatInfo.srvFormat; + } + + d3d11::SharedSRV srv; + + ANGLE_TRY(createSRVForSampler(context, key.baseLevel, key.mipLevels, format, *texture, &srv)); + + const auto &insertIt = mSrvCacheForSampler.insert(std::make_pair(key, std::move(srv))); + *outSRV = &insertIt.first->second; + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getSRVLevel(const gl::Context *context, + int mipLevel, + SRVType srvType, + const d3d11::SharedSRV **outSRV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + ANGLE_TRY(resolveTexture(context)); + if (srvType == SRVType::Stencil) + { + if (!mLevelStencilSRVs[mipLevel].valid()) + { + const TextureHelper11 *resource = nullptr; + ANGLE_TRY(getResource(context, &resource)); + + ANGLE_TRY(createSRVForSampler(context, mipLevel, 1, mFormatInfo.stencilSRVFormat, + *resource, &mLevelStencilSRVs[mipLevel])); + } + *outSRV = &mLevelStencilSRVs[mipLevel]; + return angle::Result::Continue; + } + + auto &levelSRVs = srvType == SRVType::Blit ? mLevelBlitSRVs : mLevelSRVs; + auto &otherLevelSRVs = srvType == SRVType::Blit ? mLevelSRVs : mLevelBlitSRVs; + + if (!levelSRVs[mipLevel].valid()) + { + // Only create a different SRV for blit if blit format is different from regular srv format + if (otherLevelSRVs[mipLevel].valid() && mFormatInfo.srvFormat == mFormatInfo.blitSRVFormat) + { + levelSRVs[mipLevel] = otherLevelSRVs[mipLevel].makeCopy(); + } + else + { + const TextureHelper11 *resource = nullptr; + ANGLE_TRY(getResource(context, &resource)); + + DXGI_FORMAT resourceFormat = + srvType == SRVType::Blit ? mFormatInfo.blitSRVFormat : mFormatInfo.srvFormat; + ANGLE_TRY(createSRVForSampler(context, mipLevel, 1, resourceFormat, *resource, + &levelSRVs[mipLevel])); + } + } + + *outSRV = &levelSRVs[mipLevel]; + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getSRVLevels(const gl::Context *context, + GLint baseLevel, + GLint maxLevel, + const d3d11::SharedSRV **outSRV) +{ + ANGLE_TRY(resolveTexture(context)); + unsigned int mipLevels = maxLevel - baseLevel + 1; + + // Make sure there's 'mipLevels' mipmap levels below the base level (offset by the top level, + // which corresponds to GL level 0) + mipLevels = std::min(mipLevels, mMipLevels - mTopLevel - baseLevel); + + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + ASSERT(mipLevels == 1 || mipLevels == mMipLevels); + } + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // We must ensure that the level zero texture is in sync with mipped texture. + ANGLE_TRY(useLevelZeroWorkaroundTexture(context, mipLevels == 1)); + } + + // TODO(jmadill): Assert we don't need to drop stencil. + + SamplerKey key(baseLevel, mipLevels, false, false); + ANGLE_TRY(getCachedOrCreateSRVForSampler(context, key, outSRV)); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getSRVForImage(const gl::Context *context, + const gl::ImageUnit &imageUnit, + const d3d11::SharedSRV **outSRV) +{ + ANGLE_TRY(resolveTexture(context)); + // TODO(Xinghua.cao@intel.com): Add solution to handle swizzle required. + ImageKey key(imageUnit.level, (imageUnit.layered == GL_TRUE), imageUnit.layer, imageUnit.access, + imageUnit.format); + ANGLE_TRY(getCachedOrCreateSRVForImage(context, key, outSRV)); + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getCachedOrCreateSRVForImage(const gl::Context *context, + const ImageKey &key, + const d3d11::SharedSRV **outSRV) +{ + auto iter = mSrvCacheForImage.find(key); + if (iter != mSrvCacheForImage.end()) + { + *outSRV = &iter->second; + return angle::Result::Continue; + } + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + DXGI_FORMAT format = + d3d11::Format::Get(key.format, mRenderer->getRenderer11DeviceCaps()).srvFormat; + d3d11::SharedSRV srv; + ANGLE_TRY(createSRVForImage(context, key.level, format, *texture, &srv)); + const auto &insertIt = mSrvCacheForImage.insert(std::make_pair(key, std::move(srv))); + *outSRV = &insertIt.first->second; + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getUAVForImage(const gl::Context *context, + const gl::ImageUnit &imageUnit, + const d3d11::SharedUAV **outUAV) +{ + ANGLE_TRY(resolveTexture(context)); + // TODO(Xinghua.cao@intel.com): Add solution to handle swizzle required. + ImageKey key(imageUnit.level, (imageUnit.layered == GL_TRUE), imageUnit.layer, imageUnit.access, + imageUnit.format); + ANGLE_TRY(getCachedOrCreateUAVForImage(context, key, outUAV)); + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getCachedOrCreateUAVForImage(const gl::Context *context, + const ImageKey &key, + const d3d11::SharedUAV **outUAV) +{ + auto iter = mUavCacheForImage.find(key); + if (iter != mUavCacheForImage.end()) + { + *outUAV = &iter->second; + return angle::Result::Continue; + } + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + DXGI_FORMAT format = + d3d11::Format::Get(key.format, mRenderer->getRenderer11DeviceCaps()).uavFormat; + ASSERT(format != DXGI_FORMAT_UNKNOWN); + d3d11::SharedUAV uav; + ANGLE_TRY(createUAVForImage(context, key.level, format, *texture, &uav)); + const auto &insertIt = mUavCacheForImage.insert(std::make_pair(key, std::move(uav))); + *outUAV = &insertIt.first->second; + return angle::Result::Continue; +} + +const d3d11::Format &TextureStorage11::getFormatSet() const +{ + return mFormatInfo; +} + +angle::Result TextureStorage11::generateSwizzles(const gl::Context *context, + const gl::TextureState &textureState) +{ + ANGLE_TRY(resolveTexture(context)); + gl::SwizzleState swizzleTarget = GetEffectiveSwizzle(textureState); + for (int level = 0; level < getLevelCount(); level++) + { + // Check if the swizzle for this level is out of date + if (mSwizzleCache[level] != swizzleTarget) + { + // Need to re-render the swizzle for this level + const d3d11::SharedSRV *sourceSRV = nullptr; + ANGLE_TRY(getSRVLevel(context, level, + textureState.isStencilMode() ? SRVType::Stencil : SRVType::Blit, + &sourceSRV)); + + const d3d11::RenderTargetView *destRTV; + ANGLE_TRY(getSwizzleRenderTarget(context, level, &destRTV)); + + gl::Extents size(getLevelWidth(level), getLevelHeight(level), getLevelDepth(level)); + + Blit11 *blitter = mRenderer->getBlitter(); + + ANGLE_TRY(blitter->swizzleTexture(context, *sourceSRV, *destRTV, size, swizzleTarget)); + + mSwizzleCache[level] = swizzleTarget; + } + } + + return angle::Result::Continue; +} + +void TextureStorage11::markLevelDirty(int mipLevel) +{ + if (mipLevel >= 0 && static_cast<size_t>(mipLevel) < mSwizzleCache.size()) + { + // The default constructor of SwizzleState has GL_INVALID_INDEX for all channels which is + // not a valid swizzle combination + if (mSwizzleCache[mipLevel] != gl::SwizzleState()) + { + // TODO(jmadill): Invalidate specific swizzle. + mRenderer->getStateManager()->invalidateSwizzles(); + mSwizzleCache[mipLevel] = gl::SwizzleState(); + } + } + + if (mDropStencilTexture.valid()) + { + mDropStencilTexture.reset(); + } +} + +void TextureStorage11::markDirty() +{ + for (size_t mipLevel = 0; mipLevel < mSwizzleCache.size(); ++mipLevel) + { + markLevelDirty(static_cast<int>(mipLevel)); + } +} + +angle::Result TextureStorage11::updateSubresourceLevel(const gl::Context *context, + const TextureHelper11 &srcTexture, + unsigned int sourceSubresource, + const gl::ImageIndex &index, + const gl::Box ©Area) +{ + ASSERT(srcTexture.valid()); + + ANGLE_TRY(resolveTexture(context)); + const GLint level = index.getLevelIndex(); + + markLevelDirty(level); + + gl::Extents texSize(getLevelWidth(level), getLevelHeight(level), getLevelDepth(level)); + + bool fullCopy = copyArea.coversSameExtent(texSize); + + const TextureHelper11 *dstTexture = nullptr; + + // If the zero-LOD workaround is active and we want to update a level greater than zero, then we + // should update the mipmapped texture, even if mapmaps are currently disabled. + if (level > 0 && mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(getMippedResource(context, &dstTexture)); + } + else + { + ANGLE_TRY(getResource(context, &dstTexture)); + } + + unsigned int dstSubresource = 0; + ANGLE_TRY(getSubresourceIndex(context, index, &dstSubresource)); + + ASSERT(dstTexture->valid()); + + const d3d11::DXGIFormatSize &dxgiFormatSizeInfo = + d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat); + if (!fullCopy && mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) + { + // CopySubresourceRegion cannot copy partial depth stencils, use the blitter instead + Blit11 *blitter = mRenderer->getBlitter(); + return blitter->copyDepthStencil(context, srcTexture, sourceSubresource, copyArea, texSize, + *dstTexture, dstSubresource, copyArea, texSize, nullptr); + } + + D3D11_BOX srcBox; + srcBox.left = copyArea.x; + srcBox.top = copyArea.y; + srcBox.right = + copyArea.x + roundUp(static_cast<UINT>(copyArea.width), dxgiFormatSizeInfo.blockWidth); + srcBox.bottom = + copyArea.y + roundUp(static_cast<UINT>(copyArea.height), dxgiFormatSizeInfo.blockHeight); + srcBox.front = copyArea.z; + srcBox.back = copyArea.z + copyArea.depth; + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + deviceContext->CopySubresourceRegion(dstTexture->get(), dstSubresource, copyArea.x, copyArea.y, + copyArea.z, srcTexture.get(), sourceSubresource, + fullCopy ? nullptr : &srcBox); + return angle::Result::Continue; +} + +angle::Result TextureStorage11::copySubresourceLevel(const gl::Context *context, + const TextureHelper11 &dstTexture, + unsigned int dstSubresource, + const gl::ImageIndex &index, + const gl::Box ®ion) +{ + ASSERT(dstTexture.valid()); + + ANGLE_TRY(resolveTexture(context)); + const TextureHelper11 *srcTexture = nullptr; + + // If the zero-LOD workaround is active and we want to update a level greater than zero, then we + // should update the mipmapped texture, even if mapmaps are currently disabled. + if (index.getLevelIndex() > 0 && mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ANGLE_TRY(getMippedResource(context, &srcTexture)); + } + else + { + ANGLE_TRY(getResource(context, &srcTexture)); + } + + ASSERT(srcTexture->valid()); + + unsigned int srcSubresource = 0; + ANGLE_TRY(getSubresourceIndex(context, index, &srcSubresource)); + + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // D3D11 can't perform partial CopySubresourceRegion on depth/stencil textures, so pSrcBox + // should be nullptr. + D3D11_BOX srcBox; + D3D11_BOX *pSrcBox = nullptr; + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3) + { + GLsizei width = region.width; + GLsizei height = region.height; + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, nullptr); + + // Keep srcbox as nullptr if we're dealing with tiny mips of compressed textures. + if (width == region.width && height == region.height) + { + // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless + // the source box is specified. This is okay, since we don't perform + // CopySubresourceRegion on depth/stencil textures on 9_3. + ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN); + srcBox.left = region.x; + srcBox.right = region.x + region.width; + srcBox.top = region.y; + srcBox.bottom = region.y + region.height; + srcBox.front = region.z; + srcBox.back = region.z + region.depth; + pSrcBox = &srcBox; + } + } + + deviceContext->CopySubresourceRegion(dstTexture.get(), dstSubresource, region.x, region.y, + region.z, srcTexture->get(), srcSubresource, pSrcBox); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) +{ + ASSERT(sourceIndex.getLayerIndex() == destIndex.getLayerIndex()); + + ANGLE_TRY(resolveTexture(context)); + markLevelDirty(destIndex.getLevelIndex()); + + RenderTargetD3D *source = nullptr; + ANGLE_TRY(getRenderTarget(context, sourceIndex, 0, &source)); + + // dest will always have 0 since, we have just released the MS Texture struct + RenderTargetD3D *dest = nullptr; + ANGLE_TRY(getRenderTarget(context, destIndex, 0, &dest)); + + RenderTarget11 *srcRT11 = GetAs<RenderTarget11>(source); + RenderTarget11 *dstRT11 = GetAs<RenderTarget11>(dest); + const d3d11::RenderTargetView &destRTV = dstRT11->getRenderTargetView(); + const d3d11::SharedSRV *sourceSRV; + ANGLE_TRY(srcRT11->getBlitShaderResourceView(context, &sourceSRV)); + + gl::Box sourceArea(0, 0, 0, source->getWidth(), source->getHeight(), source->getDepth()); + gl::Extents sourceSize(source->getWidth(), source->getHeight(), source->getDepth()); + + gl::Box destArea(0, 0, 0, dest->getWidth(), dest->getHeight(), dest->getDepth()); + gl::Extents destSize(dest->getWidth(), dest->getHeight(), dest->getDepth()); + + Blit11 *blitter = mRenderer->getBlitter(); + const gl::InternalFormat &sourceInternalFormat = + gl::GetSizedInternalFormatInfo(source->getInternalFormat()); + GLenum format = sourceInternalFormat.format; + GLenum type = sourceInternalFormat.type; + return blitter->copyTexture(context, *sourceSRV, sourceArea, sourceSize, format, destRTV, + destArea, destSize, nullptr, format, type, GL_LINEAR, false, false, + false); +} + +void TextureStorage11::verifySwizzleExists(const gl::SwizzleState &swizzleState) +{ + for (unsigned int level = 0; level < mMipLevels; level++) + { + ASSERT(mSwizzleCache[level] == swizzleState); + } +} + +void TextureStorage11::clearSRVCache() +{ + markDirty(); + mSrvCacheForSampler.clear(); + + for (size_t level = 0; level < mLevelSRVs.size(); level++) + { + mLevelSRVs[level].reset(); + mLevelBlitSRVs[level].reset(); + } +} + +angle::Result TextureStorage11::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + + ANGLE_TRY(resolveTexture(context)); + const TextureHelper11 *sourceResouce = nullptr; + ANGLE_TRY(getResource(context, &sourceResouce)); + + TextureStorage11 *dest11 = GetAs<TextureStorage11>(destStorage); + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + immediateContext->CopyResource(destResource->get(), sourceResouce->get()); + + dest11->markDirty(); + + return angle::Result::Continue; +} + +void TextureStorage11::invalidateTextures() +{ + mRenderer->getStateManager()->invalidateTexturesAndSamplers(); +} + +angle::Result TextureStorage11::setData(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D *image, + const gl::Box *destBox, + GLenum type, + const gl::PixelUnpackState &unpack, + const uint8_t *pixelData) +{ + ASSERT(!image->isDirty()); + + ANGLE_TRY(resolveTexture(context)); + markLevelDirty(index.getLevelIndex()); + + const TextureHelper11 *resource = nullptr; + ANGLE_TRY(getResource(context, &resource)); + ASSERT(resource && resource->valid()); + + UINT destSubresource = 0; + ANGLE_TRY(getSubresourceIndex(context, index, &destSubresource)); + + const gl::InternalFormat &internalFormatInfo = + gl::GetInternalFormatInfo(image->getInternalFormat(), type); + + gl::Box levelBox(0, 0, 0, getLevelWidth(index.getLevelIndex()), + getLevelHeight(index.getLevelIndex()), getLevelDepth(index.getLevelIndex())); + bool fullUpdate = (destBox == nullptr || *destBox == levelBox); + ASSERT(internalFormatInfo.depthBits == 0 || fullUpdate); + + // TODO(jmadill): Handle compressed formats + // Compressed formats have different load syntax, so we'll have to handle them with slightly + // different logic. Will implemnent this in a follow-up patch, and ensure we do not use SetData + // with compressed formats in the calling logic. + ASSERT(!internalFormatInfo.compressed); + + Context11 *context11 = GetImplAs<Context11>(context); + + const int width = destBox ? destBox->width : static_cast<int>(image->getWidth()); + const int height = destBox ? destBox->height : static_cast<int>(image->getHeight()); + const int depth = destBox ? destBox->depth : static_cast<int>(image->getDepth()); + GLuint srcRowPitch = 0; + ANGLE_CHECK_GL_MATH(context11, + internalFormatInfo.computeRowPitch(type, width, unpack.alignment, + unpack.rowLength, &srcRowPitch)); + GLuint srcDepthPitch = 0; + ANGLE_CHECK_GL_MATH(context11, internalFormatInfo.computeDepthPitch( + height, unpack.imageHeight, srcRowPitch, &srcDepthPitch)); + GLuint srcSkipBytes = 0; + ANGLE_CHECK_GL_MATH( + context11, internalFormatInfo.computeSkipBytes(type, srcRowPitch, srcDepthPitch, unpack, + index.usesTex3D(), &srcSkipBytes)); + + const d3d11::Format &d3d11Format = + d3d11::Format::Get(image->getInternalFormat(), mRenderer->getRenderer11DeviceCaps()); + const d3d11::DXGIFormatSize &dxgiFormatInfo = + d3d11::GetDXGIFormatSizeInfo(d3d11Format.texFormat); + + const size_t outputPixelSize = dxgiFormatInfo.pixelBytes; + + UINT bufferRowPitch = static_cast<unsigned int>(outputPixelSize) * width; + UINT bufferDepthPitch = bufferRowPitch * height; + + const size_t neededSize = bufferDepthPitch * depth; + angle::MemoryBuffer *conversionBuffer = nullptr; + const uint8_t *data = nullptr; + + LoadImageFunctionInfo loadFunctionInfo = d3d11Format.getLoadFunctions()(type); + if (loadFunctionInfo.requiresConversion) + { + ANGLE_TRY(mRenderer->getScratchMemoryBuffer(context11, neededSize, &conversionBuffer)); + loadFunctionInfo.loadFunction(width, height, depth, pixelData + srcSkipBytes, srcRowPitch, + srcDepthPitch, conversionBuffer->data(), bufferRowPitch, + bufferDepthPitch); + data = conversionBuffer->data(); + } + else + { + data = pixelData + srcSkipBytes; + bufferRowPitch = srcRowPitch; + bufferDepthPitch = srcDepthPitch; + } + + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + + if (!fullUpdate) + { + ASSERT(destBox); + + D3D11_BOX destD3DBox; + destD3DBox.left = destBox->x; + destD3DBox.right = destBox->x + destBox->width; + destD3DBox.top = destBox->y; + destD3DBox.bottom = destBox->y + destBox->height; + destD3DBox.front = destBox->z; + destD3DBox.back = destBox->z + destBox->depth; + + immediateContext->UpdateSubresource(resource->get(), destSubresource, &destD3DBox, data, + bufferRowPitch, bufferDepthPitch); + } + else + { + immediateContext->UpdateSubresource(resource->get(), destSubresource, nullptr, data, + bufferRowPitch, bufferDepthPitch); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::ensureDropStencilTexture( + const gl::Context *context, + TextureStorage11::DropStencil *dropStencilOut) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11::initDropStencilTexture(const gl::Context *context, + const gl::ImageIndexIterator &it) +{ + const TextureHelper11 *sourceTexture = nullptr; + ANGLE_TRY(getResource(context, &sourceTexture)); + + gl::ImageIndexIterator itCopy = it; + + while (itCopy.hasNext()) + { + gl::ImageIndex index = itCopy.next(); + gl::Box wholeArea(0, 0, 0, getLevelWidth(index.getLevelIndex()), + getLevelHeight(index.getLevelIndex()), 1); + gl::Extents wholeSize(wholeArea.width, wholeArea.height, 1); + + UINT subresource = 0; + ANGLE_TRY(getSubresourceIndex(context, index, &subresource)); + + ANGLE_TRY(mRenderer->getBlitter()->copyDepthStencil( + context, *sourceTexture, subresource, wholeArea, wholeSize, mDropStencilTexture, + subresource, wholeArea, wholeSize, nullptr)); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11::resolveTextureHelper(const gl::Context *context, + const TextureHelper11 &texture) +{ + UINT subresourceIndexSS; + ANGLE_TRY(getSubresourceIndex(context, mMSTexInfo->indexSS, &subresourceIndexSS)); + UINT subresourceIndexMS; + ANGLE_TRY(getSubresourceIndex(context, mMSTexInfo->indexMS, &subresourceIndexMS)); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + const TextureHelper11 *resource = nullptr; + ANGLE_TRY(mMSTexInfo->msTex->getResource(context, &resource)); + deviceContext->ResolveSubresource(texture.get(), subresourceIndexSS, resource->get(), + subresourceIndexMS, texture.getFormat()); + mMSTexInfo->msTextureNeedsResolve = false; + return angle::Result::Continue; +} + +angle::Result TextureStorage11::releaseMultisampledTexStorageForLevel(size_t level) +{ + if (mMSTexInfo && mMSTexInfo->indexSS.getLevelIndex() == static_cast<int>(level)) + { + mMSTexInfo->msTex.reset(); + onStateChange(angle::SubjectMessage::ContentsChanged); + } + return angle::Result::Continue; +} + +GLsizei TextureStorage11::getRenderToTextureSamples() const +{ + if (mMSTexInfo) + { + return mMSTexInfo->samples; + } + return 0; +} + +angle::Result TextureStorage11::findMultisampledRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + const int level = index.getLevelIndex(); + if (!mMSTexInfo || level != mMSTexInfo->indexSS.getLevelIndex() || + samples != mMSTexInfo->samples || !mMSTexInfo->msTex) + { + *outRT = nullptr; + return angle::Result::Continue; + } + RenderTargetD3D *rt; + ANGLE_TRY(mMSTexInfo->msTex->findRenderTarget(context, mMSTexInfo->indexMS, samples, &rt)); + *outRT = rt; + return angle::Result::Continue; +} + +angle::Result TextureStorage11::getMultisampledRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + const int level = index.getLevelIndex(); + if (!mMSTexInfo || level != mMSTexInfo->indexSS.getLevelIndex() || + samples != mMSTexInfo->samples || !mMSTexInfo->msTex) + { + // if mMSTexInfo already exists, then we want to resolve and release it + // since the mMSTexInfo must be for a different sample count or level + ANGLE_TRY(resolveTexture(context)); + + // Now we can create a new object for the correct sample and level + GLsizei width = getLevelWidth(level); + GLsizei height = getLevelHeight(level); + GLenum internalFormat = mFormatInfo.internalFormat; + std::unique_ptr<TextureStorage11_2DMultisample> texMS( + GetAs<TextureStorage11_2DMultisample>(mRenderer->createTextureStorage2DMultisample( + internalFormat, width, height, level, samples, true, mKHRDebugLabel))); + + // make sure multisample object has the blitted information. + gl::Rectangle area(0, 0, width, height); + RenderTargetD3D *readRenderTarget = nullptr; + // use incoming index here since the index will correspond to the single sampled texture + ANGLE_TRY(getRenderTarget(context, index, 0, &readRenderTarget)); + gl::ImageIndex indexMS = gl::ImageIndex::Make2DMultisample(); + RenderTargetD3D *drawRenderTarget = nullptr; + ANGLE_TRY(texMS->getRenderTarget(context, indexMS, samples, &drawRenderTarget)); + + // blit SS -> MS + // mask: GL_COLOR_BUFFER_BIT, filter: GL_NEAREST + ANGLE_TRY(mRenderer->blitRenderbufferRect(context, area, area, 0, 0, readRenderTarget, + drawRenderTarget, GL_NEAREST, nullptr, true, + false, false)); + mMSTexInfo = std::make_unique<MultisampledRenderToTextureInfo>(samples, index, indexMS); + mMSTexInfo->msTex = std::move(texMS); + } + RenderTargetD3D *rt; + ANGLE_TRY(mMSTexInfo->msTex->getRenderTarget(context, mMSTexInfo->indexMS, samples, &rt)); + // By returning the multisampled render target to the caller, the render target + // is expected to be changed so we need to resolve to a single sampled texture + // next time resolveTexture is called. + mMSTexInfo->msTextureNeedsResolve = true; + *outRT = rt; + return angle::Result::Continue; +} + +TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, + SwapChain11 *swapchain, + const std::string &label) + : TextureStorage11(renderer, + D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, + 0, + swapchain->getRenderTargetInternalFormat(), + label), + mTexture(swapchain->getOffscreenTexture()), + mLevelZeroTexture(), + mLevelZeroRenderTarget(nullptr), + mUseLevelZeroTexture(false), + mSwizzleTexture() +{ + for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + mAssociatedImages[i] = nullptr; + mRenderTarget[i] = nullptr; + } + + D3D11_TEXTURE2D_DESC texDesc; + mTexture.getDesc(&texDesc); + mMipLevels = texDesc.MipLevels; + mTextureWidth = texDesc.Width; + mTextureHeight = texDesc.Height; + mTextureDepth = 1; + mHasKeyedMutex = (texDesc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0; +} + +TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) + : TextureStorage11( + renderer, + GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), bindFlags), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + bindFlags, + levels), + internalformat, + label), + mTexture(), + mHasKeyedMutex(false), + mLevelZeroTexture(), + mLevelZeroRenderTarget(nullptr), + mUseLevelZeroTexture(hintLevelZeroOnly && levels > 1), + mSwizzleTexture() +{ + for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + mAssociatedImages[i] = nullptr; + mRenderTarget[i] = nullptr; + } + + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); + mMipLevels = mTopLevel + levels; + mTextureWidth = width; + mTextureHeight = height; + mTextureDepth = 1; + + // The LevelZeroOnly hint should only be true if the zero max LOD workaround is active. + ASSERT(!mUseLevelZeroTexture || mRenderer->getFeatures().zeroMaxLodWorkaround.enabled); +} + +void TextureStorage11_2D::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mLevelZeroTexture.valid()) + { + mLevelZeroTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mSwizzleTexture.valid()) + { + mSwizzleTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +angle::Result TextureStorage11_2D::onDestroy(const gl::Context *context) +{ + for (unsigned i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + if (mAssociatedImages[i] != nullptr) + { + mAssociatedImages[i]->verifyAssociatedStorageValid(this); + + // We must let the Images recover their data before we delete it from the + // TextureStorage. + ANGLE_TRY(mAssociatedImages[i]->recoverFromAssociatedStorage(context)); + } + } + + if (mHasKeyedMutex) + { + // If the keyed mutex is released that will unbind it and cause the state cache to become + // desynchronized. + mRenderer->getStateManager()->invalidateBoundViews(); + } + + return angle::Result::Continue; +} + +TextureStorage11_2D::~TextureStorage11_2D() {} + +angle::Result TextureStorage11_2D::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + + TextureStorage11_2D *dest11 = GetAs<TextureStorage11_2D>(destStorage); + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + // If either mTexture or mLevelZeroTexture exist, then we need to copy them into the + // corresponding textures in destStorage. + if (mTexture.valid()) + { + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(context, false)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + immediateContext->CopyResource(destResource->get(), mTexture.get()); + } + + if (mLevelZeroTexture.valid()) + { + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(context, true)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + immediateContext->CopyResource(destResource->get(), mLevelZeroTexture.get()); + } + + return angle::Result::Continue; + } + + const TextureHelper11 *sourceResouce = nullptr; + ANGLE_TRY(getResource(context, &sourceResouce)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + immediateContext->CopyResource(destResource->get(), sourceResouce->get()); + dest11->markDirty(); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) +{ + if (useLevelZeroTexture && mMipLevels > 1) + { + if (!mUseLevelZeroTexture && mTexture.valid()) + { + ANGLE_TRY(ensureTextureExists(context, 1)); + + // Pull data back from the mipped texture if necessary. + ASSERT(mLevelZeroTexture.valid()); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->CopySubresourceRegion(mLevelZeroTexture.get(), 0, 0, 0, 0, + mTexture.get(), 0, nullptr); + } + + mUseLevelZeroTexture = true; + } + else + { + if (mUseLevelZeroTexture && mLevelZeroTexture.valid()) + { + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + + // Pull data back from the level zero texture if necessary. + ASSERT(mTexture.valid()); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + deviceContext->CopySubresourceRegion(mTexture.get(), 0, 0, 0, 0, + mLevelZeroTexture.get(), 0, nullptr); + } + + mUseLevelZeroTexture = false; + } + + return angle::Result::Continue; +} + +void TextureStorage11_2D::associateImage(Image11 *image, const gl::ImageIndex &index) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + mAssociatedImages[level] = image; + } +} + +void TextureStorage11_2D::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + // This validation check should never return false. It means the Image/TextureStorage + // association is broken. + ASSERT(mAssociatedImages[level] == expectedImage); +} + +// disassociateImage allows an Image to end its association with a Storage. +void TextureStorage11_2D::disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(mAssociatedImages[level] == expectedImage); + mAssociatedImages[level] = nullptr; +} + +// releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image +// recover its data before ending the association. +angle::Result TextureStorage11_2D::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + + if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + // No need to let the old Image recover its data, if it is also the incoming Image. + if (mAssociatedImages[level] != nullptr && mAssociatedImages[level] != incomingImage) + { + // Ensure that the Image is still associated with this TextureStorage. + mAssociatedImages[level]->verifyAssociatedStorageValid(this); + + // Force the image to recover from storage before its data is overwritten. + // This will reset mAssociatedImages[level] to nullptr too. + ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage(context)); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + if (mUseLevelZeroTexture && mMipLevels > 1) + { + ANGLE_TRY(ensureTextureExists(context, 1)); + + *outResource = &mLevelZeroTexture; + return angle::Result::Continue; + } + + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + // This shouldn't be called unless the zero max LOD workaround is active. + ASSERT(mRenderer->getFeatures().zeroMaxLodWorkaround.enabled); + + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::ensureTextureExists(const gl::Context *context, int mipLevels) +{ + // If mMipLevels = 1 then always use mTexture rather than mLevelZeroTexture. + ANGLE_TRY(resolveTexture(context)); + bool useLevelZeroTexture = mRenderer->getFeatures().zeroMaxLodWorkaround.enabled + ? (mipLevels == 1) && (mMipLevels > 1) + : false; + TextureHelper11 *outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture; + + // 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 (!outputTexture->valid() && mTextureWidth > 0 && mTextureHeight > 0) + { + ASSERT(mipLevels > 0); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; // Compressed texture size constraints? + desc.Height = mTextureHeight; + desc.MipLevels = mipLevels; + desc.ArraySize = 1; + desc.Format = isUnorderedAccess() ? mFormatInfo.typelessFormat : mFormatInfo.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = getBindFlags(); + desc.CPUAccessFlags = 0; + desc.MiscFlags = getMiscFlags(); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + outputTexture)); + + if (useLevelZeroTexture) + { + outputTexture->setLabels("TexStorage2D.Level0Texture", &mKHRDebugLabel); + } + else + { + outputTexture->setLabels("TexStorage2D.Texture", &mKHRDebugLabel); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(!index.hasLayer()); + + const int level = index.getLevelIndex(); + ASSERT(level >= 0 && level < getLevelCount()); + + bool needMS = samples > 0; + if (needMS) + { + return findMultisampledRenderTarget(context, index, samples, outRT); + } + + ASSERT(outRT); + if (mRenderTarget[level]) + { + *outRT = mRenderTarget[level].get(); + return angle::Result::Continue; + } + + if (mUseLevelZeroTexture) + { + ASSERT(level == 0); + *outRT = mLevelZeroRenderTarget.get(); + return angle::Result::Continue; + } + + *outRT = nullptr; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + + const int level = index.getLevelIndex(); + ASSERT(level >= 0 && level < getLevelCount()); + + bool needMS = samples > 0; + if (needMS) + { + return getMultisampledRenderTarget(context, index, samples, outRT); + } + else + { + ANGLE_TRY(resolveTexture(context)); + } + + // In GL ES 2.0, the application can only render to level zero of the texture (Section 4.4.3 of + // the GLES 2.0 spec, page 113 of version 2.0.25). Other parts of TextureStorage11_2D could + // create RTVs on non-zero levels of the texture (e.g. generateMipmap). + // On Feature Level 9_3, this is unlikely to be useful. The renderer can't create SRVs on the + // individual levels of the texture, so methods like generateMipmap can't do anything useful + // with non-zero-level RTVs. Therefore if level > 0 on 9_3 then there's almost certainly + // something wrong. + ASSERT( + !(mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3 && level > 0)); + ASSERT(outRT); + if (mRenderTarget[level]) + { + *outRT = mRenderTarget[level].get(); + return angle::Result::Continue; + } + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ASSERT(level == 0); + ANGLE_TRY(useLevelZeroWorkaroundTexture(context, true)); + } + + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + + const d3d11::SharedSRV *srv = nullptr; + ANGLE_TRY(getSRVLevel(context, level, SRVType::Sample, &srv)); + + const d3d11::SharedSRV *blitSRV = nullptr; + ANGLE_TRY(getSRVLevel(context, level, SRVType::Blit, &blitSRV)); + + Context11 *context11 = GetImplAs<Context11>(context); + + if (mUseLevelZeroTexture) + { + if (!mLevelZeroRenderTarget) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtvDesc.Texture2D.MipSlice = mTopLevel + level; + + d3d11::RenderTargetView rtv; + ANGLE_TRY( + mRenderer->allocateResource(context11, rtvDesc, mLevelZeroTexture.get(), &rtv)); + rtv.setLabels("TexStorage2D.Level0RTV", &mKHRDebugLabel); + + mLevelZeroRenderTarget.reset(new TextureRenderTarget11( + std::move(rtv), mLevelZeroTexture, d3d11::SharedSRV(), d3d11::SharedSRV(), + mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), + getLevelHeight(level), 1, 0)); + } + + *outRT = mLevelZeroRenderTarget.get(); + return angle::Result::Continue; + } + + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtvDesc.Texture2D.MipSlice = mTopLevel + level; + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv)); + rtv.setLabels("TexStorage2D.RTV", &mKHRDebugLabel); + + mRenderTarget[level].reset(new TextureRenderTarget11( + std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(level), getLevelHeight(level), 1, 0)); + + *outRT = mRenderTarget[level].get(); + return angle::Result::Continue; + } + + ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); + + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = mFormatInfo.dsvFormat; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + dsvDesc.Texture2D.MipSlice = mTopLevel + level; + dsvDesc.Flags = 0; + + d3d11::DepthStencilView dsv; + ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, texture->get(), &dsv)); + dsv.setLabels("TexStorage2D.DSV", &mKHRDebugLabel); + + mRenderTarget[level].reset(new TextureRenderTarget11( + std::move(dsv), *texture, *srv, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(level), getLevelHeight(level), 1, 0)); + + *outRT = mRenderTarget[level].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = mTopLevel + baseLevel; + srvDesc.Texture2D.MipLevels = mipLevels; + + const TextureHelper11 *srvTexture = &texture; + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ASSERT(mTopLevel == 0); + ASSERT(baseLevel == 0); + // This code also assumes that the incoming texture equals either mLevelZeroTexture or + // mTexture. + + if (mipLevels == 1 && mMipLevels > 1) + { + // We must use a SRV on the level-zero-only texture. + ANGLE_TRY(ensureTextureExists(context, 1)); + srvTexture = &mLevelZeroTexture; + } + else + { + ASSERT(mipLevels == static_cast<int>(mMipLevels)); + ASSERT(mTexture.valid() && texture == mTexture); + srvTexture = &mTexture; + } + } + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, srvTexture->get(), + outSRV)); + outSRV->setLabels("TexStorage2D.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = mTopLevel + level; + srvDesc.Texture2D.MipLevels = 1; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2D.SRVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ASSERT(outUAV); + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + uavDesc.Format = format; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D; + uavDesc.Texture2D.MipSlice = mTopLevel + level; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV)); + outUAV->setLabels("TexStorage2D.UAVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ASSERT(outTexture); + + if (!mSwizzleTexture.valid()) + { + const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mMipLevels; + desc.ArraySize = 1; + desc.Format = format.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format, + &mSwizzleTexture)); + mSwizzleTexture.setLabels("TexStorage2D.SwizzleTexture", &mKHRDebugLabel); + } + + *outTexture = &mSwizzleTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + ASSERT(outRTV); + + if (!mSwizzleRenderTargets[mipLevel].valid()) + { + const TextureHelper11 *swizzleTexture = nullptr; + ANGLE_TRY(getSwizzleTexture(context, &swizzleTexture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + mSwizzleTexture.get(), + &mSwizzleRenderTargets[mipLevel])); + } + + *outRTV = &mSwizzleRenderTargets[mipLevel]; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) +{ + if (mDropStencilTexture.valid()) + { + *dropStencilOut = DropStencil::ALREADY_EXISTS; + return angle::Result::Continue; + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = 1; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = 0; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + const auto &format = + d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps()); + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format, + &mDropStencilTexture)); + mDropStencilTexture.setLabels("TexStorage2D.DropStencil", &mKHRDebugLabel); + + ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::Make2D(0, mMipLevels))); + + *dropStencilOut = DropStencil::CREATED; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2D::resolveTexture(const gl::Context *context) +{ + if (mMSTexInfo && mMSTexInfo->msTex && mMSTexInfo->msTextureNeedsResolve) + { + ANGLE_TRY(resolveTextureHelper(context, mTexture)); + onStateChange(angle::SubjectMessage::ContentsChanged); + } + return angle::Result::Continue; +} + +TextureStorage11_External::TextureStorage11_External( + Renderer11 *renderer, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &glDesc, + const std::string &label) + : TextureStorage11(renderer, D3D11_BIND_SHADER_RESOURCE, 0, glDesc.internalFormat, label) +{ + ASSERT(stream->getProducerType() == egl::Stream::ProducerType::D3D11Texture); + auto *producer = static_cast<StreamProducerD3DTexture *>(stream->getImplementation()); + mTexture.set(producer->getD3DTexture(), mFormatInfo); + mSubresourceIndex = producer->getArraySlice(); + mTexture.get()->AddRef(); + mMipLevels = 1; + + D3D11_TEXTURE2D_DESC desc; + mTexture.getDesc(&desc); + mTextureWidth = desc.Width; + mTextureHeight = desc.Height; + mTextureDepth = 1; + mHasKeyedMutex = (desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0; +} + +angle::Result TextureStorage11_External::onDestroy(const gl::Context *context) +{ + if (mHasKeyedMutex) + { + // If the keyed mutex is released that will unbind it and cause the state cache to become + // desynchronized. + mRenderer->getStateManager()->invalidateBoundViews(); + } + + return angle::Result::Continue; +} + +TextureStorage11_External::~TextureStorage11_External() {} + +angle::Result TextureStorage11_External::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + UNIMPLEMENTED(); + return angle::Result::Continue; +} + +void TextureStorage11_External::associateImage(Image11 *image, const gl::ImageIndex &index) +{ + ASSERT(index.getLevelIndex() == 0); + mAssociatedImage = image; +} + +void TextureStorage11_External::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + ASSERT(index.getLevelIndex() == 0 && mAssociatedImage == expectedImage); +} + +void TextureStorage11_External::disassociateImage(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + ASSERT(index.getLevelIndex() == 0); + ASSERT(mAssociatedImage == expectedImage); + mAssociatedImage = nullptr; +} + +angle::Result TextureStorage11_External::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + ASSERT(index.getLevelIndex() == 0); + + if (mAssociatedImage != nullptr && mAssociatedImage != incomingImage) + { + mAssociatedImage->verifyAssociatedStorageValid(this); + + ANGLE_TRY(mAssociatedImage->recoverFromAssociatedStorage(context)); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_External::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_External::getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_External::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + // Render targets are not supported for external textures + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_External::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + // Render targets are not supported for external textures + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_External::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + // Since external textures are treates as non-mipmapped textures, we ignore mipmap levels and + // use the specified subresource ID the storage was created with. + ASSERT(mipLevels == 1); + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + // subresource index is equal to the mip level for 2D textures + srvDesc.Texture2DArray.MostDetailedMip = 0; + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = mSubresourceIndex; + srvDesc.Texture2DArray.ArraySize = 1; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2D.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_External::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_External::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_External::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_External::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +void TextureStorage11_External::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11ImmutableBase::TextureStorage11ImmutableBase(Renderer11 *renderer, + UINT bindFlags, + UINT miscFlags, + GLenum internalFormat, + const std::string &label) + : TextureStorage11(renderer, bindFlags, miscFlags, internalFormat, label) +{} + +void TextureStorage11ImmutableBase::associateImage(Image11 *, const gl::ImageIndex &) {} + +void TextureStorage11ImmutableBase::disassociateImage(const gl::ImageIndex &, Image11 *) {} + +void TextureStorage11ImmutableBase::verifyAssociatedImageValid(const gl::ImageIndex &, Image11 *) {} + +angle::Result TextureStorage11ImmutableBase::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &, + Image11 *) +{ + return angle::Result::Continue; +} + +angle::Result TextureStorage11ImmutableBase::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11ImmutableBase::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer, + EGLImageD3D *eglImage, + RenderTarget11 *renderTarget11, + const std::string &label) + : TextureStorage11ImmutableBase(renderer, + D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, + 0, + renderTarget11->getInternalFormat(), + label), + mImage(eglImage), + mCurrentRenderTarget(0), + mSwizzleTexture(), + mSwizzleRenderTargets(gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) +{ + mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11); + + mMipLevels = 1; + mTextureWidth = renderTarget11->getWidth(); + mTextureHeight = renderTarget11->getHeight(); + mTextureDepth = 1; +} + +TextureStorage11_EGLImage::~TextureStorage11_EGLImage() {} + +angle::Result TextureStorage11_EGLImage::getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const +{ + ASSERT(index.getType() == gl::TextureType::_2D); + ASSERT(index.getLevelIndex() == 0); + + RenderTarget11 *renderTarget11 = nullptr; + ANGLE_TRY(getImageRenderTarget(context, &renderTarget11)); + *outSubresourceIndex = renderTarget11->getSubresourceIndex(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + ANGLE_TRY(checkForUpdatedRenderTarget(context)); + + RenderTarget11 *renderTarget11 = nullptr; + ANGLE_TRY(getImageRenderTarget(context, &renderTarget11)); + *outResource = &renderTarget11->getTexture(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::getSRVForSampler(const gl::Context *context, + const gl::TextureState &textureState, + const gl::SamplerState &sampler, + const d3d11::SharedSRV **outSRV) +{ + ANGLE_TRY(checkForUpdatedRenderTarget(context)); + return TextureStorage11::getSRVForSampler(context, textureState, sampler, outSRV); +} + +angle::Result TextureStorage11_EGLImage::getMippedResource(const gl::Context *context, + const TextureHelper11 **) +{ + // This shouldn't be called unless the zero max LOD workaround is active. + // EGL images are unavailable in this configuration. + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_EGLImage::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + // Since the render target of an EGL image will be updated when orphaning, trying to find a + // cache of it can be rarely useful. + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_EGLImage::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + ASSERT(index.getLevelIndex() == 0); + + ANGLE_TRY(checkForUpdatedRenderTarget(context)); + + return mImage->getRenderTarget(context, outRT); +} + +angle::Result TextureStorage11_EGLImage::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + const TextureHelper11 *sourceResouce = nullptr; + ANGLE_TRY(getResource(context, &sourceResouce)); + + ASSERT(destStorage); + TextureStorage11_2D *dest11 = GetAs<TextureStorage11_2D>(destStorage); + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + immediateContext->CopyResource(destResource->get(), sourceResouce->get()); + + dest11->markDirty(); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::useLevelZeroWorkaroundTexture(const gl::Context *context, + bool) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_EGLImage::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ASSERT(outTexture); + + if (!mSwizzleTexture.valid()) + { + const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mMipLevels; + desc.ArraySize = 1; + desc.Format = format.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format, + &mSwizzleTexture)); + mSwizzleTexture.setLabels("TexStorageEGLImage.SwizzleTexture", &mKHRDebugLabel); + } + + *outTexture = &mSwizzleTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + ASSERT(outRTV); + + if (!mSwizzleRenderTargets[mipLevel].valid()) + { + const TextureHelper11 *swizzleTexture = nullptr; + ANGLE_TRY(getSwizzleTexture(context, &swizzleTexture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + mSwizzleTexture.get(), + &mSwizzleRenderTargets[mipLevel])); + } + + *outRTV = &mSwizzleRenderTargets[mipLevel]; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::checkForUpdatedRenderTarget(const gl::Context *context) +{ + RenderTarget11 *renderTarget11 = nullptr; + ANGLE_TRY(getImageRenderTarget(context, &renderTarget11)); + + if (mCurrentRenderTarget != reinterpret_cast<uintptr_t>(renderTarget11)) + { + clearSRVCache(); + mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(baseLevel == 0); + ASSERT(mipLevels == 1); + ASSERT(outSRV); + + // Create a new SRV only for the swizzle texture. Otherwise just return the Image's + // RenderTarget's SRV. + if (texture == mSwizzleTexture) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MostDetailedMip = mTopLevel + baseLevel; + srvDesc.Texture2D.MipLevels = mipLevels; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), + outSRV)); + outSRV->setLabels("TexStorageEGLImage.SRV", &mKHRDebugLabel); + } + else + { + RenderTarget11 *renderTarget = nullptr; + ANGLE_TRY(getImageRenderTarget(context, &renderTarget)); + + ASSERT(texture == renderTarget->getTexture()); + + const d3d11::SharedSRV *srv; + ANGLE_TRY(renderTarget->getShaderResourceView(context, &srv)); + + *outSRV = srv->makeCopy(); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_EGLImage::getImageRenderTarget(const gl::Context *context, + RenderTarget11 **outRT) const +{ + RenderTargetD3D *renderTargetD3D = nullptr; + ANGLE_TRY(mImage->getRenderTarget(context, &renderTargetD3D)); + *outRT = GetAs<RenderTarget11>(renderTargetD3D); + return angle::Result::Continue; +} + +void TextureStorage11_EGLImage::onLabelUpdate() +{ + if (mSwizzleTexture.valid()) + { + mSwizzleTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) + : TextureStorage11( + renderer, + GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), bindFlags), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + bindFlags, + levels), + internalformat, + label), + mTexture(), + mLevelZeroTexture(), + mUseLevelZeroTexture(hintLevelZeroOnly && levels > 1), + mSwizzleTexture() +{ + for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + for (unsigned int face = 0; face < gl::kCubeFaceCount; face++) + { + mAssociatedImages[face][level] = nullptr; + mRenderTarget[face][level] = nullptr; + } + } + + for (unsigned int face = 0; face < gl::kCubeFaceCount; face++) + { + mLevelZeroRenderTarget[face] = nullptr; + } + + // adjust size if needed for compressed textures + int height = size; + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &size, &height, &mTopLevel); + + mMipLevels = mTopLevel + levels; + mTextureWidth = size; + mTextureHeight = size; + mTextureDepth = 1; + + // The LevelZeroOnly hint should only be true if the zero max LOD workaround is active. + ASSERT(!mUseLevelZeroTexture || mRenderer->getFeatures().zeroMaxLodWorkaround.enabled); +} + +angle::Result TextureStorage11_Cube::onDestroy(const gl::Context *context) +{ + for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) + { + for (unsigned int face = 0; face < gl::kCubeFaceCount; face++) + { + if (mAssociatedImages[face][level] != nullptr) + { + mAssociatedImages[face][level]->verifyAssociatedStorageValid(this); + + // We must let the Images recover their data before we delete it from the + // TextureStorage. + ANGLE_TRY(mAssociatedImages[face][level]->recoverFromAssociatedStorage(context)); + } + } + } + + return angle::Result::Continue; +} + +TextureStorage11_Cube::~TextureStorage11_Cube() {} + +angle::Result TextureStorage11_Cube::getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const +{ + UINT arraySlice = index.cubeMapFaceIndex(); + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled && mUseLevelZeroTexture && + index.getLevelIndex() == 0) + { + UINT subresource = D3D11CalcSubresource(0, arraySlice, 1); + ASSERT(subresource != std::numeric_limits<UINT>::max()); + *outSubresourceIndex = subresource; + } + else + { + UINT mipSlice = static_cast<UINT>(index.getLevelIndex() + mTopLevel); + UINT subresource = D3D11CalcSubresource(mipSlice, arraySlice, mMipLevels); + ASSERT(subresource != std::numeric_limits<UINT>::max()); + *outSubresourceIndex = subresource; + } + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + + TextureStorage11_Cube *dest11 = GetAs<TextureStorage11_Cube>(destStorage); + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + + // If either mTexture or mLevelZeroTexture exist, then we need to copy them into the + // corresponding textures in destStorage. + if (mTexture.valid()) + { + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(context, false)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + immediateContext->CopyResource(destResource->get(), mTexture.get()); + } + + if (mLevelZeroTexture.valid()) + { + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(context, true)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + immediateContext->CopyResource(destResource->get(), mLevelZeroTexture.get()); + } + } + else + { + const TextureHelper11 *sourceResouce = nullptr; + ANGLE_TRY(getResource(context, &sourceResouce)); + + const TextureHelper11 *destResource = nullptr; + ANGLE_TRY(dest11->getResource(context, &destResource)); + + ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); + immediateContext->CopyResource(destResource->get(), sourceResouce->get()); + } + + dest11->markDirty(); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) +{ + if (useLevelZeroTexture && mMipLevels > 1) + { + if (!mUseLevelZeroTexture && mTexture.valid()) + { + ANGLE_TRY(ensureTextureExists(context, 1)); + + // Pull data back from the mipped texture if necessary. + ASSERT(mLevelZeroTexture.valid()); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + for (int face = 0; face < 6; face++) + { + deviceContext->CopySubresourceRegion(mLevelZeroTexture.get(), + D3D11CalcSubresource(0, face, 1), 0, 0, 0, + mTexture.get(), face * mMipLevels, nullptr); + } + } + + mUseLevelZeroTexture = true; + } + else + { + if (mUseLevelZeroTexture && mLevelZeroTexture.valid()) + { + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + + // Pull data back from the level zero texture if necessary. + ASSERT(mTexture.valid()); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + for (int face = 0; face < 6; face++) + { + deviceContext->CopySubresourceRegion(mTexture.get(), + D3D11CalcSubresource(0, face, mMipLevels), 0, + 0, 0, mLevelZeroTexture.get(), face, nullptr); + } + } + + mUseLevelZeroTexture = false; + } + + return angle::Result::Continue; +} + +void TextureStorage11_Cube::associateImage(Image11 *image, const gl::ImageIndex &index) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.cubeMapFaceIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)); + + if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)) + { + mAssociatedImages[layerTarget][level] = image; + } + } +} + +void TextureStorage11_Cube::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.cubeMapFaceIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)); + // This validation check should never return false. It means the Image/TextureStorage + // association is broken. + ASSERT(mAssociatedImages[layerTarget][level] == expectedImage); +} + +// disassociateImage allows an Image to end its association with a Storage. +void TextureStorage11_Cube::disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.cubeMapFaceIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)); + ASSERT(mAssociatedImages[layerTarget][level] == expectedImage); + mAssociatedImages[layerTarget][level] = nullptr; +} + +// releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image +// recover its data before ending the association. +angle::Result TextureStorage11_Cube::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.cubeMapFaceIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)); + + if ((0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)) + { + if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount)) + { + // No need to let the old Image recover its data, if it is also the incoming Image. + if (mAssociatedImages[layerTarget][level] != nullptr && + mAssociatedImages[layerTarget][level] != incomingImage) + { + // Ensure that the Image is still associated with this TextureStorage. + mAssociatedImages[layerTarget][level]->verifyAssociatedStorageValid(this); + + // Force the image to recover from storage before its data is overwritten. + // This will reset mAssociatedImages[level] to nullptr too. + ANGLE_TRY( + mAssociatedImages[layerTarget][level]->recoverFromAssociatedStorage(context)); + } + } + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + if (mUseLevelZeroTexture && mMipLevels > 1) + { + ANGLE_TRY(ensureTextureExists(context, 1)); + *outResource = &mLevelZeroTexture; + } + else + { + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + *outResource = &mTexture; + } + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + // This shouldn't be called unless the zero max LOD workaround is active. + ASSERT(mRenderer->getFeatures().zeroMaxLodWorkaround.enabled); + + ANGLE_TRY(ensureTextureExists(context, mMipLevels)); + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::ensureTextureExists(const gl::Context *context, int mipLevels) +{ + // If mMipLevels = 1 then always use mTexture rather than mLevelZeroTexture. + ANGLE_TRY(resolveTexture(context)); + bool useLevelZeroTexture = mRenderer->getFeatures().zeroMaxLodWorkaround.enabled + ? (mipLevels == 1) && (mMipLevels > 1) + : false; + TextureHelper11 *outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture; + + // if the size is not positive this should be treated as an incomplete texture + // we handle that here by skipping the d3d texture creation + if (!outputTexture->valid() && mTextureWidth > 0 && mTextureHeight > 0) + { + ASSERT(mMipLevels > 0); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mipLevels; + desc.ArraySize = gl::kCubeFaceCount; + desc.Format = isUnorderedAccess() ? mFormatInfo.typelessFormat : mFormatInfo.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = getBindFlags(); + desc.CPUAccessFlags = 0; + desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE | getMiscFlags(); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + outputTexture)); + outputTexture->setLabels("TexStorageCube.Texture", &mKHRDebugLabel); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + const int faceIndex = index.cubeMapFaceIndex(); + const int level = index.getLevelIndex(); + + ASSERT(level >= 0 && level < getLevelCount()); + ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(gl::kCubeFaceCount)); + + bool needMS = samples > 0; + if (needMS) + { + return findMultisampledRenderTarget(context, index, samples, outRT); + } + + if (!mRenderTarget[faceIndex][level]) + { + if (mUseLevelZeroTexture) + { + ASSERT(index.getLevelIndex() == 0); + ASSERT(outRT); + *outRT = mLevelZeroRenderTarget[faceIndex].get(); + return angle::Result::Continue; + } + } + + ASSERT(outRT); + *outRT = mRenderTarget[faceIndex][level].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::createRenderTargetSRV(const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const +{ + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = resourceFormat; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + index.getLevelIndex(); + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = index.cubeMapFaceIndex(); + srvDesc.Texture2DArray.ArraySize = 1; + + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_10_0) + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + } + else + { + // Will be used with Texture2D sampler, not TextureCube + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + } + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), srv)); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + const int faceIndex = index.cubeMapFaceIndex(); + const int level = index.getLevelIndex(); + + ASSERT(level >= 0 && level < getLevelCount()); + ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(gl::kCubeFaceCount)); + + bool needMS = samples > 0; + if (needMS) + { + return getMultisampledRenderTarget(context, index, samples, outRT); + } + else + { + ANGLE_TRY(resolveTexture(context)); + } + + Context11 *context11 = GetImplAs<Context11>(context); + + if (!mRenderTarget[faceIndex][level]) + { + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ASSERT(index.getLevelIndex() == 0); + ANGLE_TRY(useLevelZeroWorkaroundTexture(context, true)); + } + + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + + if (mUseLevelZeroTexture) + { + if (!mLevelZeroRenderTarget[faceIndex]) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = mTopLevel + level; + rtvDesc.Texture2DArray.FirstArraySlice = faceIndex; + rtvDesc.Texture2DArray.ArraySize = 1; + + d3d11::RenderTargetView rtv; + ANGLE_TRY( + mRenderer->allocateResource(context11, rtvDesc, mLevelZeroTexture.get(), &rtv)); + + mLevelZeroRenderTarget[faceIndex].reset(new TextureRenderTarget11( + std::move(rtv), mLevelZeroTexture, d3d11::SharedSRV(), d3d11::SharedSRV(), + mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), + getLevelHeight(level), 1, 0)); + } + + ASSERT(outRT); + *outRT = mLevelZeroRenderTarget[faceIndex].get(); + return angle::Result::Continue; + } + + d3d11::SharedSRV srv; + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.srvFormat, &srv)); + d3d11::SharedSRV blitSRV; + if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat) + { + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.blitSRVFormat, + &blitSRV)); + } + else + { + blitSRV = srv.makeCopy(); + } + + srv.setLabels("TexStorageCube.RenderTargetSRV", &mKHRDebugLabel); + + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = mTopLevel + level; + rtvDesc.Texture2DArray.FirstArraySlice = faceIndex; + rtvDesc.Texture2DArray.ArraySize = 1; + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv)); + rtv.setLabels("TexStorageCube.RenderTargetRTV", &mKHRDebugLabel); + + mRenderTarget[faceIndex][level].reset(new TextureRenderTarget11( + std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(level), getLevelHeight(level), 1, 0)); + } + else if (mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) + { + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = mFormatInfo.dsvFormat; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; + dsvDesc.Flags = 0; + dsvDesc.Texture2DArray.MipSlice = mTopLevel + level; + dsvDesc.Texture2DArray.FirstArraySlice = faceIndex; + dsvDesc.Texture2DArray.ArraySize = 1; + + d3d11::DepthStencilView dsv; + ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, texture->get(), &dsv)); + dsv.setLabels("TexStorageCube.RenderTargetDSV", &mKHRDebugLabel); + + mRenderTarget[faceIndex][level].reset(new TextureRenderTarget11( + std::move(dsv), *texture, srv, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(level), getLevelHeight(level), 1, 0)); + } + else + { + UNREACHABLE(); + } + } + + ASSERT(outRT); + *outRT = mRenderTarget[faceIndex][level].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + + // Unnormalized integer cube maps are not supported by DX11; we emulate them as an array of six + // 2D textures + const GLenum componentType = d3d11::GetComponentType(format); + if (componentType == GL_INT || componentType == GL_UNSIGNED_INT) + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + baseLevel; + srvDesc.Texture2DArray.MipLevels = mipLevels; + srvDesc.Texture2DArray.FirstArraySlice = 0; + srvDesc.Texture2DArray.ArraySize = gl::kCubeFaceCount; + } + else + { + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + srvDesc.TextureCube.MipLevels = mipLevels; + srvDesc.TextureCube.MostDetailedMip = mTopLevel + baseLevel; + } + + const TextureHelper11 *srvTexture = &texture; + + if (mRenderer->getFeatures().zeroMaxLodWorkaround.enabled) + { + ASSERT(mTopLevel == 0); + ASSERT(baseLevel == 0); + // This code also assumes that the incoming texture equals either mLevelZeroTexture or + // mTexture. + + if (mipLevels == 1 && mMipLevels > 1) + { + // We must use a SRV on the level-zero-only texture. + ANGLE_TRY(ensureTextureExists(context, 1)); + srvTexture = &mLevelZeroTexture; + } + else + { + ASSERT(mipLevels == static_cast<int>(mMipLevels)); + ASSERT(mTexture.valid() && texture == mTexture); + srvTexture = &mTexture; + } + } + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, srvTexture->get(), + outSRV)); + outSRV->setLabels("TexStorageCube.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + level; + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = 0; + srvDesc.Texture2DArray.ArraySize = gl::kCubeFaceCount; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorageCube.SRVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ASSERT(outUAV); + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + uavDesc.Format = format; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY; + uavDesc.Texture2DArray.MipSlice = mTopLevel + level; + uavDesc.Texture2DArray.FirstArraySlice = 0; + uavDesc.Texture2DArray.ArraySize = gl::kCubeFaceCount; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV)); + outUAV->setLabels("TexStorageCube.UAVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ASSERT(outTexture); + + if (!mSwizzleTexture.valid()) + { + const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mMipLevels; + desc.ArraySize = gl::kCubeFaceCount; + desc.Format = format.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + desc.CPUAccessFlags = 0; + desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format, + &mSwizzleTexture)); + mSwizzleTexture.setLabels("TexStorageCube.SwizzleTexture", &mKHRDebugLabel); + } + + *outTexture = &mSwizzleTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + ASSERT(outRTV); + + if (!mSwizzleRenderTargets[mipLevel].valid()) + { + const TextureHelper11 *swizzleTexture = nullptr; + ANGLE_TRY(getSwizzleTexture(context, &swizzleTexture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture2DArray.FirstArraySlice = 0; + rtvDesc.Texture2DArray.ArraySize = gl::kCubeFaceCount; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + mSwizzleTexture.get(), + &mSwizzleRenderTargets[mipLevel])); + } + + *outRTV = &mSwizzleRenderTargets[mipLevel]; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) +{ + if (mDropStencilTexture.valid()) + { + *dropStencilOut = DropStencil::ALREADY_EXISTS; + return angle::Result::Continue; + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = 6; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + const auto &format = + d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps()); + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format, + &mDropStencilTexture)); + mDropStencilTexture.setLabels("TexStorageCube.DropStencil", &mKHRDebugLabel); + + ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::MakeCube(0, mMipLevels))); + + *dropStencilOut = DropStencil::CREATED; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Cube::resolveTexture(const gl::Context *context) +{ + if (mMSTexInfo && mMSTexInfo->msTex && mMSTexInfo->msTextureNeedsResolve) + { + ANGLE_TRY(resolveTextureHelper(context, mTexture)); + onStateChange(angle::SubjectMessage::ContentsChanged); + } + return angle::Result::Continue; +} + +void TextureStorage11_Cube::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mLevelZeroTexture.valid()) + { + mLevelZeroTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mSwizzleTexture.valid()) + { + mSwizzleTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) + : TextureStorage11( + renderer, + GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), bindFlags), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + bindFlags, + levels), + internalformat, + label) +{ + for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + mAssociatedImages[i] = nullptr; + mLevelRenderTargets[i] = nullptr; + } + + // adjust size if needed for compressed textures + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); + + mMipLevels = mTopLevel + levels; + mTextureWidth = width; + mTextureHeight = height; + mTextureDepth = depth; +} + +angle::Result TextureStorage11_3D::onDestroy(const gl::Context *context) +{ + for (unsigned i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) + { + if (mAssociatedImages[i] != nullptr) + { + mAssociatedImages[i]->verifyAssociatedStorageValid(this); + + // We must let the Images recover their data before we delete it from the + // TextureStorage. + ANGLE_TRY(mAssociatedImages[i]->recoverFromAssociatedStorage(context)); + } + } + + return angle::Result::Continue; +} + +TextureStorage11_3D::~TextureStorage11_3D() {} + +void TextureStorage11_3D::associateImage(Image11 *image, const gl::ImageIndex &index) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + + if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + mAssociatedImages[level] = image; + } +} + +void TextureStorage11_3D::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + // This validation check should never return false. It means the Image/TextureStorage + // association is broken. + ASSERT(mAssociatedImages[level] == expectedImage); +} + +// disassociateImage allows an Image to end its association with a Storage. +void TextureStorage11_3D::disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + ASSERT(mAssociatedImages[level] == expectedImage); + mAssociatedImages[level] = nullptr; +} + +// releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image +// recover its data before ending the association. +angle::Result TextureStorage11_3D::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + const GLint level = index.getLevelIndex(); + + ASSERT((0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)); + + if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) + { + // No need to let the old Image recover its data, if it is also the incoming Image. + if (mAssociatedImages[level] != nullptr && mAssociatedImages[level] != incomingImage) + { + // Ensure that the Image is still associated with this TextureStorage. + mAssociatedImages[level]->verifyAssociatedStorageValid(this); + + // Force the image to recover from storage before its data is overwritten. + // This will reset mAssociatedImages[level] to nullptr too. + ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage(context)); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + // If the width, height or depth are 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 && mTextureDepth > 0) + { + ASSERT(mMipLevels > 0); + + D3D11_TEXTURE3D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.Depth = mTextureDepth; + desc.MipLevels = mMipLevels; + desc.Format = isUnorderedAccess() ? mFormatInfo.typelessFormat : mFormatInfo.texFormat; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = getBindFlags(); + desc.CPUAccessFlags = 0; + desc.MiscFlags = getMiscFlags(); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + &mTexture)); + mTexture.setLabels("TexStorage3D.Texture", &mKHRDebugLabel); + } + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; + srvDesc.Texture3D.MostDetailedMip = baseLevel; + srvDesc.Texture3D.MipLevels = mipLevels; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage3D.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; + srvDesc.Texture3D.MostDetailedMip = mTopLevel + level; + srvDesc.Texture3D.MipLevels = 1; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage3D.SRVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ASSERT(outUAV); + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + uavDesc.Format = format; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D; + uavDesc.Texture3D.MipSlice = mTopLevel + level; + uavDesc.Texture3D.FirstWSlice = 0; + uavDesc.Texture3D.WSize = mTextureDepth; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV)); + outUAV->setLabels("TexStorage3D.UAVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + const int mipLevel = index.getLevelIndex(); + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + if (!index.hasLayer()) + { + ASSERT(outRT); + *outRT = mLevelRenderTargets[mipLevel].get(); + return angle::Result::Continue; + } + + const int layer = index.getLayerIndex(); + + LevelLayerKey key(mipLevel, layer); + if (mLevelLayerRenderTargets.find(key) == mLevelLayerRenderTargets.end()) + { + ASSERT(outRT); + *outRT = nullptr; + return angle::Result::Continue; + } + + ASSERT(outRT); + *outRT = mLevelLayerRenderTargets.at(key).get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + const int mipLevel = index.getLevelIndex(); + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + ASSERT(mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); + + Context11 *context11 = GetImplAs<Context11>(context); + + if (!index.hasLayer()) + { + if (!mLevelRenderTargets[mipLevel]) + { + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + + const d3d11::SharedSRV *srv = nullptr; + ANGLE_TRY(getSRVLevel(context, mipLevel, SRVType::Sample, &srv)); + + const d3d11::SharedSRV *blitSRV = nullptr; + ANGLE_TRY(getSRVLevel(context, mipLevel, SRVType::Blit, &blitSRV)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; + rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture3D.FirstWSlice = 0; + rtvDesc.Texture3D.WSize = static_cast<UINT>(-1); + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv)); + rtv.setLabels("TexStorage3D.RTV", &mKHRDebugLabel); + + mLevelRenderTargets[mipLevel].reset(new TextureRenderTarget11( + std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, + getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel), + getLevelDepth(mipLevel), 0)); + } + + ASSERT(outRT); + *outRT = mLevelRenderTargets[mipLevel].get(); + return angle::Result::Continue; + } + + const int layer = index.getLayerIndex(); + + LevelLayerKey key(mipLevel, layer); + if (mLevelLayerRenderTargets.find(key) == mLevelLayerRenderTargets.end()) + { + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; + rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture3D.FirstWSlice = layer; + rtvDesc.Texture3D.WSize = 1; + + const d3d11::SharedSRV *srv = nullptr; + ANGLE_TRY(getSRVLevel(context, mipLevel, SRVType::Sample, &srv)); + + const d3d11::SharedSRV *blitSRV = nullptr; + ANGLE_TRY(getSRVLevel(context, mipLevel, SRVType::Blit, &blitSRV)); + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv)); + rtv.setLabels("TexStorage3D.LayerRTV", &mKHRDebugLabel); + + mLevelLayerRenderTargets[key].reset(new TextureRenderTarget11( + std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0)); + } + + ASSERT(outRT); + *outRT = mLevelLayerRenderTargets[key].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ASSERT(outTexture); + + if (!mSwizzleTexture.valid()) + { + const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE3D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.Depth = mTextureDepth; + desc.MipLevels = mMipLevels; + desc.Format = format.texFormat; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format, + &mSwizzleTexture)); + mSwizzleTexture.setLabels("TexStorage3D.SwizzleTexture", &mKHRDebugLabel); + } + + *outTexture = &mSwizzleTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_3D::getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + ASSERT(outRTV); + + if (!mSwizzleRenderTargets[mipLevel].valid()) + { + const TextureHelper11 *swizzleTexture = nullptr; + ANGLE_TRY(getSwizzleTexture(context, &swizzleTexture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; + rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture3D.FirstWSlice = 0; + rtvDesc.Texture3D.WSize = static_cast<UINT>(-1); + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + mSwizzleTexture.get(), + &mSwizzleRenderTargets[mipLevel])); + mSwizzleRenderTargets[mipLevel].setLabels("TexStorage3D.SwizzleRTV", &mKHRDebugLabel); + } + + *outRTV = &mSwizzleRenderTargets[mipLevel]; + return angle::Result::Continue; +} + +void TextureStorage11_3D::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mSwizzleTexture.valid()) + { + mSwizzleTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) + : TextureStorage11( + renderer, + GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), bindFlags), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + bindFlags, + levels), + internalformat, + label) +{ + // adjust size if needed for compressed textures + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); + + mMipLevels = mTopLevel + levels; + mTextureWidth = width; + mTextureHeight = height; + mTextureDepth = depth; +} + +angle::Result TextureStorage11_2DArray::onDestroy(const gl::Context *context) +{ + for (auto iter : mAssociatedImages) + { + if (iter.second) + { + iter.second->verifyAssociatedStorageValid(this); + + // We must let the Images recover their data before we delete it from the + // TextureStorage. + ANGLE_TRY(iter.second->recoverFromAssociatedStorage(context)); + } + } + mAssociatedImages.clear(); + + return angle::Result::Continue; +} + +TextureStorage11_2DArray::~TextureStorage11_2DArray() {} + +void TextureStorage11_2DArray::associateImage(Image11 *image, const gl::ImageIndex &index) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.getLayerIndex(); + const GLint numLayers = index.getLayerCount(); + + ASSERT(0 <= level && level < getLevelCount()); + + if (0 <= level && level < getLevelCount()) + { + LevelLayerRangeKey key(level, layerTarget, numLayers); + mAssociatedImages[key] = image; + } +} + +void TextureStorage11_2DArray::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.getLayerIndex(); + const GLint numLayers = index.getLayerCount(); + + LevelLayerRangeKey key(level, layerTarget, numLayers); + + // This validation check should never return false. It means the Image/TextureStorage + // association is broken. + bool retValue = (mAssociatedImages.find(key) != mAssociatedImages.end() && + (mAssociatedImages[key] == expectedImage)); + ASSERT(retValue); +} + +// disassociateImage allows an Image to end its association with a Storage. +void TextureStorage11_2DArray::disassociateImage(const gl::ImageIndex &index, + Image11 *expectedImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.getLayerIndex(); + const GLint numLayers = index.getLayerCount(); + + LevelLayerRangeKey key(level, layerTarget, numLayers); + + bool imageAssociationCorrect = (mAssociatedImages.find(key) != mAssociatedImages.end() && + (mAssociatedImages[key] == expectedImage)); + ASSERT(imageAssociationCorrect); + mAssociatedImages[key] = nullptr; +} + +// releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image +// recover its data before ending the association. +angle::Result TextureStorage11_2DArray::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + const GLint level = index.getLevelIndex(); + const GLint layerTarget = index.getLayerIndex(); + const GLint numLayers = index.getLayerCount(); + + LevelLayerRangeKey key(level, layerTarget, numLayers); + + if (mAssociatedImages.find(key) != mAssociatedImages.end()) + { + if (mAssociatedImages[key] != nullptr && mAssociatedImages[key] != incomingImage) + { + // Ensure that the Image is still associated with this TextureStorage. + mAssociatedImages[key]->verifyAssociatedStorageValid(this); + + // Force the image to recover from storage before its data is overwritten. + // This will reset mAssociatedImages[level] to nullptr too. + ANGLE_TRY(mAssociatedImages[key]->recoverFromAssociatedStorage(context)); + } + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + // if the width, height or depth 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 && mTextureDepth > 0) + { + ASSERT(mMipLevels > 0); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mMipLevels; + desc.ArraySize = mTextureDepth; + desc.Format = isUnorderedAccess() ? mFormatInfo.typelessFormat : mFormatInfo.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = getBindFlags(); + desc.CPUAccessFlags = 0; + desc.MiscFlags = getMiscFlags(); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + &mTexture)); + mTexture.setLabels("TexStorage2DArray.Texture", &mKHRDebugLabel); + } + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + baseLevel; + srvDesc.Texture2DArray.MipLevels = mipLevels; + srvDesc.Texture2DArray.FirstArraySlice = 0; + srvDesc.Texture2DArray.ArraySize = mTextureDepth; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2DArray.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + level; + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = 0; + srvDesc.Texture2DArray.ArraySize = mTextureDepth; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2DArray.SRVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ASSERT(outUAV); + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + uavDesc.Format = format; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY; + uavDesc.Texture2DArray.MipSlice = mTopLevel + level; + uavDesc.Texture2DArray.FirstArraySlice = 0; + uavDesc.Texture2DArray.ArraySize = mTextureDepth; + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV)); + outUAV->setLabels("TexStorage2DArray.UAVForImage", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(index.hasLayer()); + + const int mipLevel = index.getLevelIndex(); + const int layer = index.getLayerIndex(); + const int numLayers = index.getLayerCount(); + + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + LevelLayerRangeKey key(mipLevel, layer, numLayers); + if (mRenderTargets.find(key) == mRenderTargets.end()) + { + ASSERT(outRT); + *outRT = nullptr; + return angle::Result::Continue; + } + + ASSERT(outRT); + *outRT = mRenderTargets.at(key).get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::createRenderTargetSRV(const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const +{ + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = resourceFormat; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + index.getLevelIndex(); + srvDesc.Texture2DArray.MipLevels = 1; + srvDesc.Texture2DArray.FirstArraySlice = index.getLayerIndex(); + srvDesc.Texture2DArray.ArraySize = index.getLayerCount(); + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), srv)); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(index.hasLayer()); + + const int mipLevel = index.getLevelIndex(); + const int layer = index.getLayerIndex(); + const int numLayers = index.getLayerCount(); + + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + LevelLayerRangeKey key(mipLevel, layer, numLayers); + if (mRenderTargets.find(key) == mRenderTargets.end()) + { + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + d3d11::SharedSRV srv; + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.srvFormat, &srv)); + d3d11::SharedSRV blitSRV; + if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat) + { + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.blitSRVFormat, + &blitSRV)); + } + else + { + blitSRV = srv.makeCopy(); + } + + srv.setLabels("TexStorage2DArray.RenderTargetSRV", &mKHRDebugLabel); + + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture2DArray.FirstArraySlice = layer; + rtvDesc.Texture2DArray.ArraySize = numLayers; + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + texture->get(), &rtv)); + rtv.setLabels("TexStorage2DArray.RenderTargetRTV", &mKHRDebugLabel); + + mRenderTargets[key].reset(new TextureRenderTarget11( + std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0)); + } + else + { + ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); + + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = mFormatInfo.dsvFormat; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; + dsvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; + dsvDesc.Texture2DArray.FirstArraySlice = layer; + dsvDesc.Texture2DArray.ArraySize = numLayers; + dsvDesc.Flags = 0; + + d3d11::DepthStencilView dsv; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), dsvDesc, + texture->get(), &dsv)); + dsv.setLabels("TexStorage2DArray.RenderTargetDSV", &mKHRDebugLabel); + + mRenderTargets[key].reset(new TextureRenderTarget11( + std::move(dsv), *texture, srv, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0)); + } + } + + ASSERT(outRT); + *outRT = mRenderTargets[key].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + if (!mSwizzleTexture.valid()) + { + const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC desc; + desc.Width = mTextureWidth; + desc.Height = mTextureHeight; + desc.MipLevels = mMipLevels; + desc.ArraySize = mTextureDepth; + desc.Format = format.texFormat; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format, + &mSwizzleTexture)); + mSwizzleTexture.setLabels("TexStorage2DArray.SwizzleTexture", &mKHRDebugLabel); + } + + *outTexture = &mSwizzleTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + ASSERT(outRTV); + + if (!mSwizzleRenderTargets[mipLevel].valid()) + { + const TextureHelper11 *swizzleTexture = nullptr; + ANGLE_TRY(getSwizzleTexture(context, &swizzleTexture)); + + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = + mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; + rtvDesc.Texture2DArray.FirstArraySlice = 0; + rtvDesc.Texture2DArray.ArraySize = mTextureDepth; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + mSwizzleTexture.get(), + &mSwizzleRenderTargets[mipLevel])); + } + + *outRTV = &mSwizzleRenderTargets[mipLevel]; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DArray::ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) +{ + if (mDropStencilTexture.valid()) + { + *dropStencilOut = DropStencil::ALREADY_EXISTS; + return angle::Result::Continue; + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = mTextureDepth; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = 0; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + const auto &format = + d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps()); + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format, + &mDropStencilTexture)); + mDropStencilTexture.setLabels("TexStorage2DArray.DropStencil", &mKHRDebugLabel); + + std::vector<GLsizei> layerCounts(mMipLevels, mTextureDepth); + + ANGLE_TRY(initDropStencilTexture( + context, gl::ImageIndexIterator::Make2DArray(0, mMipLevels, layerCounts.data()))); + + *dropStencilOut = DropStencil::CREATED; + return angle::Result::Continue; +} + +void TextureStorage11_2DArray::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } + if (mSwizzleTexture.valid()) + { + mSwizzleTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_2DMultisample::TextureStorage11_2DMultisample(Renderer11 *renderer, + GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) + : TextureStorage11ImmutableBase(renderer, + GetTextureBindFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + BindFlags::RenderTarget()), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + BindFlags::RenderTarget(), + levels), + internalformat, + label), + mTexture(), + mRenderTarget(nullptr) +{ + // There are no multisampled compressed formats, so there's no need to adjust texture size + // according to block size. + ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockWidth <= 1); + ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockHeight <= 1); + + mMipLevels = 1; + mTextureWidth = width; + mTextureHeight = height; + mTextureDepth = 1; + mSamples = samples; + mFixedSampleLocations = fixedSampleLocations; +} + +angle::Result TextureStorage11_2DMultisample::onDestroy(const gl::Context *context) +{ + mRenderTarget.reset(); + return angle::Result::Continue; +} + +TextureStorage11_2DMultisample::~TextureStorage11_2DMultisample() {} + +angle::Result TextureStorage11_2DMultisample::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisample::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + ANGLE_TRY(ensureTextureExists(context, 1)); + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisample::ensureTextureExists(const gl::Context *context, + 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() & ~D3D11_BIND_UNORDERED_ACCESS; + 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 = mRenderer->getSampleDescQuality(supportedSamples); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + &mTexture)); + mTexture.setLabels("TexStorage2DMS.Texture", &mKHRDebugLabel); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisample::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(!index.hasLayer()); + + const int level = index.getLevelIndex(); + ASSERT(level == 0); + + ASSERT(outRT); + *outRT = mRenderTarget.get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + + const int level = index.getLevelIndex(); + ASSERT(level == 0); + + ASSERT(outRT); + if (mRenderTarget) + { + *outRT = mRenderTarget.get(); + return angle::Result::Continue; + } + + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + + const d3d11::SharedSRV *srv = nullptr; + ANGLE_TRY(getSRVLevel(context, level, SRVType::Sample, &srv)); + + const d3d11::SharedSRV *blitSRV = nullptr; + ANGLE_TRY(getSRVLevel(context, level, SRVType::Blit, &blitSRV)); + + Context11 *context11 = GetImplAs<Context11>(context); + + 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(context11, 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 angle::Result::Continue; + } + + 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(context11, 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 angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisample::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2DMS.SRV", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisample::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisample::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisample::ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +void TextureStorage11_2DMultisample::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_2DMultisampleArray::TextureStorage11_2DMultisampleArray(Renderer11 *renderer, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) + : TextureStorage11ImmutableBase(renderer, + GetTextureBindFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + BindFlags::RenderTarget()), + GetTextureMiscFlags(internalformat, + renderer->getRenderer11DeviceCaps(), + BindFlags::RenderTarget(), + levels), + internalformat, + label), + mTexture() +{ + // There are no multisampled compressed formats, so there's no need to adjust texture size + // according to block size. + ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockWidth <= 1); + ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockHeight <= 1); + + mMipLevels = 1; + mTextureWidth = width; + mTextureHeight = height; + mTextureDepth = depth; + mSamples = samples; + mFixedSampleLocations = fixedSampleLocations; +} + +angle::Result TextureStorage11_2DMultisampleArray::onDestroy(const gl::Context *context) +{ + return angle::Result::Continue; +} + +TextureStorage11_2DMultisampleArray::~TextureStorage11_2DMultisampleArray() {} + +angle::Result TextureStorage11_2DMultisampleArray::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisampleArray::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + ANGLE_TRY(ensureTextureExists(context, 1)); + + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::ensureTextureExists(const gl::Context *context, + 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; + desc.Height = mTextureHeight; + desc.MipLevels = mipLevels; + desc.ArraySize = mTextureDepth; + desc.Format = mFormatInfo.texFormat; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = getBindFlags() & ~D3D11_BIND_UNORDERED_ACCESS; + 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 = mRenderer->getSampleDescQuality(supportedSamples); + + ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo, + &mTexture)); + mTexture.setLabels("TexStorage2DMSArray.Texture", &mKHRDebugLabel); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(index.hasLayer()); + + const int mipLevel = index.getLevelIndex(); + ASSERT(mipLevel == 0); + const int layer = index.getLayerIndex(); + const int numLayers = index.getLayerCount(); + + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + TextureStorage11_2DArray::LevelLayerRangeKey key(mipLevel, layer, numLayers); + if (mRenderTargets.find(key) == mRenderTargets.end()) + { + ASSERT(outRT); + *outRT = nullptr; + return angle::Result::Continue; + } + + ASSERT(outRT); + *outRT = mRenderTargets.at(key).get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::createRenderTargetSRV( + const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const +{ + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = resourceFormat; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; + srvDesc.Texture2DMSArray.FirstArraySlice = index.getLayerIndex(); + srvDesc.Texture2DMSArray.ArraySize = index.getLayerCount(); + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), srv)); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(index.hasLayer()); + + const int mipLevel = index.getLevelIndex(); + ASSERT(mipLevel == 0); + const int layer = index.getLayerIndex(); + const int numLayers = index.getLayerCount(); + + ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); + + TextureStorage11_2DArray::LevelLayerRangeKey key(mipLevel, layer, numLayers); + if (mRenderTargets.find(key) == mRenderTargets.end()) + { + const TextureHelper11 *texture = nullptr; + ANGLE_TRY(getResource(context, &texture)); + d3d11::SharedSRV srv; + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.srvFormat, &srv)); + d3d11::SharedSRV blitSRV; + if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat) + { + ANGLE_TRY(createRenderTargetSRV(context, *texture, index, mFormatInfo.blitSRVFormat, + &blitSRV)); + } + else + { + blitSRV = srv.makeCopy(); + } + + srv.setLabels("TexStorage2DMSArray.RenderTargetSRV", &mKHRDebugLabel); + + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) + { + D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; + rtvDesc.Format = mFormatInfo.rtvFormat; + rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY; + rtvDesc.Texture2DMSArray.FirstArraySlice = layer; + rtvDesc.Texture2DMSArray.ArraySize = numLayers; + + d3d11::RenderTargetView rtv; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc, + texture->get(), &rtv)); + rtv.setLabels("TexStorage2DMSArray.RenderTargetRTV", &mKHRDebugLabel); + + mRenderTargets[key].reset(new TextureRenderTarget11( + std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, mSamples)); + } + else + { + ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); + + D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; + dsvDesc.Format = mFormatInfo.dsvFormat; + dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY; + dsvDesc.Texture2DMSArray.FirstArraySlice = layer; + dsvDesc.Texture2DMSArray.ArraySize = numLayers; + dsvDesc.Flags = 0; + + d3d11::DepthStencilView dsv; + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), dsvDesc, + texture->get(), &dsv)); + dsv.setLabels("TexStorage2DMSArray.RenderTargetDSV", &mKHRDebugLabel); + + mRenderTargets[key].reset(new TextureRenderTarget11( + std::move(dsv), *texture, srv, mFormatInfo.internalFormat, getFormatSet(), + getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, mSamples)); + } + } + + ASSERT(outRT); + *outRT = mRenderTargets[key].get(); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::createSRVForSampler( + const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(outSRV); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; + srvDesc.Texture2DMSArray.FirstArraySlice = 0; + srvDesc.Texture2DMSArray.ArraySize = mTextureDepth; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexStorage2DMSArray.SRV", &mKHRDebugLabel); + return angle::Result::Continue; +} + +angle::Result TextureStorage11_2DMultisampleArray::getSwizzleTexture( + const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisampleArray::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_2DMultisampleArray::ensureDropStencilTexture( + const gl::Context *context, + DropStencil *dropStencilOut) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +void TextureStorage11_2DMultisampleArray::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +TextureStorage11_Buffer::TextureStorage11_Buffer(Renderer11 *renderer, + const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) + : TextureStorage11(renderer, + D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE, + 0, + internalFormat, + label), + mTexture(), + mBuffer(buffer), + mDataSize(GetBoundBufferAvailableSize(buffer)) +{ + unsigned int bytesPerPixel = + static_cast<unsigned int>(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.srvFormat).pixelBytes); + mMipLevels = 1; + mTextureWidth = static_cast<unsigned int>(mDataSize / bytesPerPixel); + mTextureHeight = 1; + mTextureDepth = 1; +} + +TextureStorage11_Buffer::~TextureStorage11_Buffer() {} + +angle::Result TextureStorage11_Buffer::initTexture(const gl::Context *context) +{ + if (!mTexture.valid()) + { + ID3D11Buffer *buffer = nullptr; + Buffer11 *buffer11 = GetImplAs<Buffer11>(mBuffer.get()); + ANGLE_TRY(buffer11->getBuffer(context, rx::BufferUsage::BUFFER_USAGE_TYPED_UAV, &buffer)); + mTexture.set(buffer, mFormatInfo); + mTexture.get()->AddRef(); + } + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Buffer::getResource(const gl::Context *context, + const TextureHelper11 **outResource) +{ + ANGLE_TRY(initTexture(context)); + *outResource = &mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Buffer::getMippedResource(const gl::Context *context, + const TextureHelper11 **) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_Buffer::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_Buffer::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_Buffer::getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_Buffer::getSwizzleRenderTarget( + const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context11>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage11_Buffer::createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ASSERT(baseLevel == 0); + ASSERT(mipLevels == 1); + ASSERT(outSRV); + ANGLE_TRY(initTexture(context)); + UINT bytesPerPixel = static_cast<UINT>(d3d11::GetDXGIFormatSizeInfo(format).pixelBytes); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + ASSERT(mBuffer.getOffset() % bytesPerPixel == 0); + srvDesc.Buffer.FirstElement = static_cast<UINT>(mBuffer.getOffset() / bytesPerPixel); + srvDesc.Buffer.NumElements = static_cast<UINT>(mDataSize / bytesPerPixel); + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexBuffer.SRV", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +angle::Result TextureStorage11_Buffer::createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) +{ + ANGLE_TRY(initTexture(context)); + UINT bytesPerPixel = static_cast<UINT>(d3d11::GetDXGIFormatSizeInfo(format).pixelBytes); + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + srvDesc.Format = format; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + ASSERT(mBuffer.getOffset() % bytesPerPixel == 0); + srvDesc.Buffer.FirstElement = static_cast<UINT>(mBuffer.getOffset() / bytesPerPixel); + srvDesc.Buffer.NumElements = static_cast<UINT>(mDataSize / bytesPerPixel); + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV)); + outSRV->setLabels("TexBuffer.SRVForImage", &mKHRDebugLabel); + + return angle::Result::Continue; +} +angle::Result TextureStorage11_Buffer::createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) +{ + ANGLE_TRY(initTexture(context)); + unsigned bytesPerPixel = d3d11::GetDXGIFormatSizeInfo(format).pixelBytes; + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; + uavDesc.Format = format; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; + ASSERT(mBuffer.getOffset() % bytesPerPixel == 0); + uavDesc.Buffer.FirstElement = static_cast<UINT>(mBuffer.getOffset() / bytesPerPixel); + uavDesc.Buffer.NumElements = static_cast<UINT>(mDataSize / bytesPerPixel); + uavDesc.Buffer.Flags = 0; + + ANGLE_TRY( + mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV)); + outUAV->setLabels("TexBuffer.UAVForImage", &mKHRDebugLabel); + + return angle::Result::Continue; +} + +void TextureStorage11_Buffer::associateImage(Image11 *image, const gl::ImageIndex &index) {} +void TextureStorage11_Buffer::disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) +{} +void TextureStorage11_Buffer::verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) +{} +angle::Result TextureStorage11_Buffer::releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) +{ + return angle::Result::Continue; +} + +void TextureStorage11_Buffer::onLabelUpdate() +{ + if (mTexture.valid()) + { + mTexture.setKHRDebugLabel(&mKHRDebugLabel); + } +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h new file mode 100644 index 0000000000..72bc1b802c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h @@ -0,0 +1,1003 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureStorage11.h: Defines the abstract rx::TextureStorage11 class and its concrete derived +// classes TextureStorage11_2D and TextureStorage11_Cube, which act as the interface to the D3D11 +// texture. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_ + +#include "libANGLE/Error.h" +#include "libANGLE/Texture.h" +#include "libANGLE/renderer/d3d/TextureStorage.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +#include <array> +#include <map> + +namespace gl +{ +class ImageIndex; +} // namespace gl + +namespace rx +{ +class EGLImageD3D; +class RenderTargetD3D; +class RenderTarget11; +class Renderer11; +class SwapChain11; +class Image11; +struct Renderer11DeviceCaps; +class TextureStorage11_2DMultisample; + +template <typename T> +using CubeFaceArray = std::array<T, gl::kCubeFaceCount>; + +struct MultisampledRenderToTextureInfo +{ + MultisampledRenderToTextureInfo(const GLsizei samples, + const gl::ImageIndex &indexSS, + const gl::ImageIndex &indexMS); + ~MultisampledRenderToTextureInfo(); + + // How many samples the multisampled texture contains + GLsizei samples; + // This is the image index for the single sampled texture + // This will hold the relevant level information + gl::ImageIndex indexSS; + // This is the image index for the multisampled texture + // For multisampled indexes, there is no level Index since they should + // account for the entire level. + gl::ImageIndex indexMS; + // True when multisampled texture has been written to and needs to be + // resolved to the single sampled texture + bool msTextureNeedsResolve; + std::unique_ptr<TextureStorage11_2DMultisample> msTex; +}; + +class TextureStorage11 : public TextureStorage +{ + public: + ~TextureStorage11() override; + + static DWORD GetTextureBindFlags(GLenum internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + BindFlags flags); + static DWORD GetTextureMiscFlags(GLenum internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + BindFlags flags, + int levels); + + UINT getBindFlags() const; + UINT getMiscFlags() const; + const d3d11::Format &getFormatSet() const; + angle::Result getSRVLevels(const gl::Context *context, + GLint baseLevel, + GLint maxLevel, + const d3d11::SharedSRV **outSRV); + angle::Result generateSwizzles(const gl::Context *context, + const gl::TextureState &textureState); + void markLevelDirty(int mipLevel); + void markDirty(); + + angle::Result updateSubresourceLevel(const gl::Context *context, + const TextureHelper11 &texture, + unsigned int sourceSubresource, + const gl::ImageIndex &index, + const gl::Box ©Area); + + angle::Result copySubresourceLevel(const gl::Context *context, + const TextureHelper11 &dstTexture, + unsigned int dstSubresource, + const gl::ImageIndex &index, + const gl::Box ®ion); + + // TextureStorage virtual functions + int getTopLevel() const override; + bool isRenderTarget() const override; + bool isManaged() const override; + bool supportsNativeMipmapFunction() const override; + int getLevelCount() const override; + bool isUnorderedAccess() const override { return mBindFlags & D3D11_BIND_UNORDERED_ACCESS; } + angle::Result generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) override; + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + angle::Result setData(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D *image, + const gl::Box *destBox, + GLenum type, + const gl::PixelUnpackState &unpack, + const uint8_t *pixelData) override; + void invalidateTextures() override; + + virtual angle::Result getSRVForSampler(const gl::Context *context, + const gl::TextureState &textureState, + const gl::SamplerState &sampler, + const d3d11::SharedSRV **outSRV); + angle::Result getSRVForImage(const gl::Context *context, + const gl::ImageUnit &imageUnit, + const d3d11::SharedSRV **outSRV); + angle::Result getUAVForImage(const gl::Context *context, + const gl::ImageUnit &imageUnit, + const d3d11::SharedUAV **outUAV); + virtual angle::Result getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const; + virtual angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) = 0; + virtual void associateImage(Image11 *image, const gl::ImageIndex &index) = 0; + virtual void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) = 0; + virtual void verifyAssociatedImageValid(const gl::ImageIndex &index, + Image11 *expectedImage) = 0; + virtual angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) = 0; + + GLsizei getRenderToTextureSamples() const override; + + protected: + TextureStorage11(Renderer11 *renderer, + UINT bindFlags, + UINT miscFlags, + GLenum internalFormat, + const std::string &label); + int getLevelWidth(int mipLevel) const; + int getLevelHeight(int mipLevel) const; + int getLevelDepth(int mipLevel) const; + + // Some classes (e.g. TextureStorage11_2D) will override getMippedResource. + virtual angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource); + + virtual angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) = 0; + virtual angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) = 0; + + enum class SRVType + { + Sample, + Blit, + Stencil + }; + angle::Result getSRVLevel(const gl::Context *context, + int mipLevel, + SRVType srvType, + const d3d11::SharedSRV **outSRV); + + // Get a version of a depth texture with only depth information, not stencil. + enum DropStencil + { + CREATED, + ALREADY_EXISTS + }; + virtual angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut); + angle::Result initDropStencilTexture(const gl::Context *context, + const gl::ImageIndexIterator &it); + + // The baseLevel parameter should *not* have mTopLevel applied. + virtual angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) = 0; + virtual angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) = 0; + virtual angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) = 0; + + void verifySwizzleExists(const gl::SwizzleState &swizzleState); + + // Clear all cached non-swizzle SRVs and invalidate the swizzle cache. + void clearSRVCache(); + + // Helper for resolving MS shadowed texture + angle::Result resolveTextureHelper(const gl::Context *context, const TextureHelper11 &texture); + angle::Result releaseMultisampledTexStorageForLevel(size_t level) override; + angle::Result findMultisampledRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const; + angle::Result getMultisampledRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT); + + Renderer11 *mRenderer; + int mTopLevel; + unsigned int mMipLevels; + + const d3d11::Format &mFormatInfo; + unsigned int mTextureWidth; + unsigned int mTextureHeight; + unsigned int mTextureDepth; + + gl::TexLevelArray<gl::SwizzleState> mSwizzleCache; + TextureHelper11 mDropStencilTexture; + + std::unique_ptr<MultisampledRenderToTextureInfo> mMSTexInfo; + + private: + const UINT mBindFlags; + const UINT mMiscFlags; + + struct SamplerKey + { + SamplerKey(); + SamplerKey(int baseLevel, int mipLevels, bool swizzle, bool dropStencil); + + bool operator<(const SamplerKey &rhs) const; + + int baseLevel; + int mipLevels; + bool swizzle; + bool dropStencil; + }; + + angle::Result getCachedOrCreateSRVForSampler(const gl::Context *context, + const SamplerKey &key, + const d3d11::SharedSRV **outSRV); + + using SRVCacheForSampler = std::map<SamplerKey, d3d11::SharedSRV>; + SRVCacheForSampler mSrvCacheForSampler; + + struct ImageKey + { + ImageKey(); + ImageKey(int level, bool layered, int layer, GLenum access, GLenum format); + bool operator<(const ImageKey &rhs) const; + int level; + bool layered; + int layer; + GLenum access; + GLenum format; + }; + + angle::Result getCachedOrCreateSRVForImage(const gl::Context *context, + const ImageKey &key, + const d3d11::SharedSRV **outSRV); + angle::Result getCachedOrCreateUAVForImage(const gl::Context *context, + const ImageKey &key, + const d3d11::SharedUAV **outUAV); + + using SRVCacheForImage = std::map<ImageKey, d3d11::SharedSRV>; + SRVCacheForImage mSrvCacheForImage; + using UAVCacheForImage = std::map<ImageKey, d3d11::SharedUAV>; + UAVCacheForImage mUavCacheForImage; + + gl::TexLevelArray<d3d11::SharedSRV> mLevelSRVs; + gl::TexLevelArray<d3d11::SharedSRV> mLevelBlitSRVs; + gl::TexLevelArray<d3d11::SharedSRV> mLevelStencilSRVs; +}; + +class TextureStorage11_2D : public TextureStorage11 +{ + public: + TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain, const std::string &label); + TextureStorage11_2D(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly = false); + ~TextureStorage11_2D() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + + angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) override; + + angle::Result ensureTextureExists(const gl::Context *context, int mipLevels); + + angle::Result resolveTexture(const gl::Context *context) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + + TextureHelper11 mTexture; + gl::TexLevelArray<std::unique_ptr<RenderTarget11>> mRenderTarget; + bool mHasKeyedMutex; + + // These are members related to the zero max-LOD workaround. + // D3D11 Feature Level 9_3 can't disable mipmaps on a mipmapped texture (i.e. solely sample from + // level zero). These members are used to work around this limitation. Usually only mTexture XOR + // mLevelZeroTexture will exist. For example, if an app creates a texture with only one level, + // then 9_3 will only create mLevelZeroTexture. However, in some scenarios, both textures have + // to be created. This incurs additional memory overhead. One example of this is an application + // that creates a texture, calls glGenerateMipmap, and then disables mipmaps on the texture. A + // more likely example is an app that creates an empty texture, renders to it, and then calls + // glGenerateMipmap + // TODO: In this rendering scenario, release the mLevelZeroTexture after mTexture has been + // created to save memory. + TextureHelper11 mLevelZeroTexture; + std::unique_ptr<RenderTarget11> mLevelZeroRenderTarget; + bool mUseLevelZeroTexture; + + // Swizzle-related variables + TextureHelper11 mSwizzleTexture; + gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets; + + gl::TexLevelArray<Image11 *> mAssociatedImages; +}; + +class TextureStorage11_External : public TextureStorage11 +{ + public: + TextureStorage11_External(Renderer11 *renderer, + egl::Stream *stream, + const egl::Stream::GLTextureDescription &glDesc, + const std::string &label); + ~TextureStorage11_External() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + + TextureHelper11 mTexture; + int mSubresourceIndex; + bool mHasKeyedMutex; + + Image11 *mAssociatedImage; +}; + +// A base class for texture storage classes where the associated images are not changed, nor are +// they accessible as images in GLES3.1+ shaders. +class TextureStorage11ImmutableBase : public TextureStorage11 +{ + public: + TextureStorage11ImmutableBase(Renderer11 *renderer, + UINT bindFlags, + UINT miscFlags, + GLenum internalFormat, + const std::string &label); + + 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; +}; + +class TextureStorage11_EGLImage final : public TextureStorage11ImmutableBase +{ + public: + TextureStorage11_EGLImage(Renderer11 *renderer, + EGLImageD3D *eglImage, + RenderTarget11 *renderTarget11, + const std::string &label); + ~TextureStorage11_EGLImage() override; + + angle::Result getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const override; + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result getSRVForSampler(const gl::Context *context, + const gl::TextureState &textureState, + const gl::SamplerState &sampler, + const d3d11::SharedSRV **outSRV) override; + angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + + angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + private: + // Check if the EGL image's render target has been updated due to orphaning and delete + // any SRVs and other resources based on the image's old render target. + angle::Result checkForUpdatedRenderTarget(const gl::Context *context); + + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + + angle::Result getImageRenderTarget(const gl::Context *context, RenderTarget11 **outRT) const; + + EGLImageD3D *mImage; + uintptr_t mCurrentRenderTarget; + + // Swizzle-related variables + TextureHelper11 mSwizzleTexture; + std::vector<d3d11::RenderTargetView> mSwizzleRenderTargets; +}; + +class TextureStorage11_Cube : public TextureStorage11 +{ + public: + TextureStorage11_Cube(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label); + ~TextureStorage11_Cube() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getSubresourceIndex(const gl::Context *context, + const gl::ImageIndex &index, + UINT *outSubresourceIndex) const override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + + angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context, + bool useLevelZeroTexture) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) override; + + angle::Result ensureTextureExists(const gl::Context *context, int mipLevels); + + angle::Result resolveTexture(const gl::Context *context) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + angle::Result createRenderTargetSRV(const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const; + + TextureHelper11 mTexture; + CubeFaceArray<gl::TexLevelArray<std::unique_ptr<RenderTarget11>>> mRenderTarget; + + // Level-zero workaround members. See TextureStorage11_2D's workaround members for a + // description. + TextureHelper11 mLevelZeroTexture; + CubeFaceArray<std::unique_ptr<RenderTarget11>> mLevelZeroRenderTarget; + bool mUseLevelZeroTexture; + + TextureHelper11 mSwizzleTexture; + gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets; + + CubeFaceArray<gl::TexLevelArray<Image11 *>> mAssociatedImages; +}; + +class TextureStorage11_3D : public TextureStorage11 +{ + public: + TextureStorage11_3D(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label); + ~TextureStorage11_3D() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + + // Handles both layer and non-layer RTs + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + + typedef std::pair<int, int> LevelLayerKey; + std::map<LevelLayerKey, std::unique_ptr<RenderTarget11>> mLevelLayerRenderTargets; + + gl::TexLevelArray<std::unique_ptr<RenderTarget11>> mLevelRenderTargets; + + TextureHelper11 mTexture; + TextureHelper11 mSwizzleTexture; + gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets; + + gl::TexLevelArray<Image11 *> mAssociatedImages; +}; + +class TextureStorage11_2DArray : public TextureStorage11 +{ + public: + TextureStorage11_2DArray(Renderer11 *renderer, + GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label); + ~TextureStorage11_2DArray() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + void onLabelUpdate() override; + + struct LevelLayerRangeKey + { + LevelLayerRangeKey(int mipLevelIn, int layerIn, int numLayersIn) + : mipLevel(mipLevelIn), layer(layerIn), numLayers(numLayersIn) + {} + bool operator<(const LevelLayerRangeKey &other) const + { + if (mipLevel != other.mipLevel) + { + return mipLevel < other.mipLevel; + } + if (layer != other.layer) + { + return layer < other.layer; + } + return numLayers < other.numLayers; + } + int mipLevel; + int layer; + int numLayers; + }; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + angle::Result createRenderTargetSRV(const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const; + + std::map<LevelLayerRangeKey, std::unique_ptr<RenderTarget11>> mRenderTargets; + + TextureHelper11 mTexture; + + TextureHelper11 mSwizzleTexture; + gl::TexLevelArray<d3d11::RenderTargetView> mSwizzleRenderTargets; + + typedef std::map<LevelLayerRangeKey, Image11 *> ImageMap; + ImageMap mAssociatedImages; +}; + +class TextureStorage11_2DMultisample final : public TextureStorage11ImmutableBase +{ + public: + TextureStorage11_2DMultisample(Renderer11 *renderer, + GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label); + ~TextureStorage11_2DMultisample() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) override; + + angle::Result ensureTextureExists(const gl::Context *context, int mipLevels); + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + + TextureHelper11 mTexture; + std::unique_ptr<RenderTarget11> mRenderTarget; + + unsigned int mSamples; + GLboolean mFixedSampleLocations; +}; + +class TextureStorage11_2DMultisampleArray final : public TextureStorage11ImmutableBase +{ + public: + TextureStorage11_2DMultisampleArray(Renderer11 *renderer, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label); + ~TextureStorage11_2DMultisampleArray() override; + + angle::Result onDestroy(const gl::Context *context) override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + void onLabelUpdate() override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + angle::Result ensureDropStencilTexture(const gl::Context *context, + DropStencil *dropStencilOut) override; + + angle::Result ensureTextureExists(const gl::Context *context, int mipLevels); + + private: + angle::Result createRenderTargetSRV(const gl::Context *context, + const TextureHelper11 &texture, + const gl::ImageIndex &index, + DXGI_FORMAT resourceFormat, + d3d11::SharedSRV *srv) const; + + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + + TextureHelper11 mTexture; + std::map<TextureStorage11_2DArray::LevelLayerRangeKey, std::unique_ptr<RenderTarget11>> + mRenderTargets; + + unsigned int mSamples; + GLboolean mFixedSampleLocations; +}; + +class TextureStorage11_Buffer : public TextureStorage11 +{ + public: + TextureStorage11_Buffer(Renderer11 *renderer, + const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label); + ~TextureStorage11_Buffer() override; + + angle::Result getResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result getMippedResource(const gl::Context *context, + const TextureHelper11 **outResource) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + + void onLabelUpdate() 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; + angle::Result releaseAssociatedImage(const gl::Context *context, + const gl::ImageIndex &index, + Image11 *incomingImage) override; + + protected: + angle::Result getSwizzleTexture(const gl::Context *context, + const TextureHelper11 **outTexture) override; + angle::Result getSwizzleRenderTarget(const gl::Context *context, + int mipLevel, + const d3d11::RenderTargetView **outRTV) override; + + private: + angle::Result createSRVForSampler(const gl::Context *context, + int baseLevel, + int mipLevels, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createSRVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedSRV *outSRV) override; + angle::Result createUAVForImage(const gl::Context *context, + int level, + DXGI_FORMAT format, + const TextureHelper11 &texture, + d3d11::SharedUAV *outUAV) override; + + angle::Result initTexture(const gl::Context *context); + + TextureHelper11 mTexture; + const gl::OffsetBindingPointer<gl::Buffer> &mBuffer; + GLint64 mDataSize; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp new file mode 100644 index 0000000000..1dcd62cd45 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp @@ -0,0 +1,131 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TransformFeedbackD3D.cpp is a no-op implementation for both the D3D9 and D3D11 renderers. + +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" + +#include "libANGLE/Buffer.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +TransformFeedback11::TransformFeedback11(const gl::TransformFeedbackState &state, + Renderer11 *renderer) + : TransformFeedbackImpl(state), + mRenderer(renderer), + mIsDirty(true), + mBuffers(state.getIndexedBuffers().size(), nullptr), + mBufferOffsets(state.getIndexedBuffers().size(), 0), + mSerial(mRenderer->generateSerial()) +{} + +TransformFeedback11::~TransformFeedback11() {} + +angle::Result TransformFeedback11::begin(const gl::Context *context, + gl::PrimitiveMode primitiveMode) +{ + // Reset all the cached offsets to the binding offsets + mIsDirty = true; + for (size_t bindingIdx = 0; bindingIdx < mBuffers.size(); bindingIdx++) + { + const auto &binding = mState.getIndexedBuffer(bindingIdx); + if (binding.get() != nullptr) + { + mBufferOffsets[bindingIdx] = static_cast<UINT>(binding.getOffset()); + } + else + { + mBufferOffsets[bindingIdx] = 0; + } + } + mRenderer->getStateManager()->invalidateTransformFeedback(); + return angle::Result::Continue; +} + +angle::Result TransformFeedback11::end(const gl::Context *context) +{ + mRenderer->getStateManager()->invalidateTransformFeedback(); + if (mRenderer->getFeatures().flushAfterEndingTransformFeedback.enabled) + { + mRenderer->getDeviceContext()->Flush(); + } + return angle::Result::Continue; +} + +angle::Result TransformFeedback11::pause(const gl::Context *context) +{ + mRenderer->getStateManager()->invalidateTransformFeedback(); + return angle::Result::Continue; +} + +angle::Result TransformFeedback11::resume(const gl::Context *context) +{ + mRenderer->getStateManager()->invalidateTransformFeedback(); + return angle::Result::Continue; +} + +angle::Result TransformFeedback11::bindIndexedBuffer( + const gl::Context *context, + size_t index, + const gl::OffsetBindingPointer<gl::Buffer> &binding) +{ + mIsDirty = true; + mBufferOffsets[index] = static_cast<UINT>(binding.getOffset()); + mRenderer->getStateManager()->invalidateTransformFeedback(); + return angle::Result::Continue; +} + +void TransformFeedback11::onApply() +{ + mIsDirty = false; + + // Change all buffer offsets to -1 so that if any of them need to be re-applied, the are set to + // append + std::fill(mBufferOffsets.begin(), mBufferOffsets.end(), -1); +} + +bool TransformFeedback11::isDirty() const +{ + return mIsDirty; +} + +UINT TransformFeedback11::getNumSOBuffers() const +{ + return static_cast<UINT>(mBuffers.size()); +} + +angle::Result TransformFeedback11::getSOBuffers(const gl::Context *context, + const std::vector<ID3D11Buffer *> **buffersOut) +{ + for (size_t bindingIdx = 0; bindingIdx < mBuffers.size(); bindingIdx++) + { + const auto &binding = mState.getIndexedBuffer(bindingIdx); + if (binding.get() != nullptr) + { + Buffer11 *storage = GetImplAs<Buffer11>(binding.get()); + ANGLE_TRY(storage->getBuffer(context, BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK, + &mBuffers[bindingIdx])); + } + } + + *buffersOut = &mBuffers; + return angle::Result::Continue; +} + +const std::vector<UINT> &TransformFeedback11::getSOBufferOffsets() const +{ + return mBufferOffsets; +} + +Serial TransformFeedback11::getSerial() const +{ + return mSerial; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h new file mode 100644 index 0000000000..69ae90671b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h @@ -0,0 +1,61 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TransformFeedback11.h: Implements the abstract rx::TransformFeedbackImpl class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ + +#include "common/platform.h" + +#include "libANGLE/Error.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/TransformFeedbackImpl.h" +#include "libANGLE/renderer/serial_utils.h" + +namespace rx +{ + +class Renderer11; + +class TransformFeedback11 : public TransformFeedbackImpl +{ + public: + TransformFeedback11(const gl::TransformFeedbackState &state, Renderer11 *renderer); + ~TransformFeedback11() override; + + angle::Result begin(const gl::Context *context, gl::PrimitiveMode primitiveMode) override; + angle::Result end(const gl::Context *context) override; + angle::Result pause(const gl::Context *context) override; + angle::Result resume(const gl::Context *context) override; + + angle::Result bindIndexedBuffer(const gl::Context *context, + size_t index, + const gl::OffsetBindingPointer<gl::Buffer> &binding) override; + + void onApply(); + + bool isDirty() const; + + UINT getNumSOBuffers() const; + angle::Result getSOBuffers(const gl::Context *context, + const std::vector<ID3D11Buffer *> **buffersOut); + const std::vector<UINT> &getSOBufferOffsets() const; + + Serial getSerial() const; + + private: + Renderer11 *mRenderer; + + bool mIsDirty; + std::vector<ID3D11Buffer *> mBuffers; + std::vector<UINT> mBufferOffsets; + + Serial mSerial; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp new file mode 100644 index 0000000000..ac6d9a5220 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp @@ -0,0 +1,103 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Trim11.cpp: Trim support utility class. + +#include "libANGLE/renderer/d3d/d3d11/Trim11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#if defined(ANGLE_ENABLE_WINDOWS_UWP) +# include <windows.applicationmodel.core.h> +# include <wrl.h> +# include <wrl/wrappers/corewrappers.h> +using namespace Microsoft::WRL; +using namespace Microsoft::WRL::Wrappers; +using namespace ABI::Windows::ApplicationModel; +using namespace ABI::Windows::ApplicationModel::Core; +using namespace ABI::Windows::Foundation; +using namespace ABI::Windows::Foundation::Collections; +#endif + +namespace rx +{ + +Trim11::Trim11(rx::Renderer11 *renderer) : mRenderer(renderer) +{ + bool result = true; + result = registerForRendererTrimRequest(); + ASSERT(result); +} + +Trim11::~Trim11() +{ + unregisterForRendererTrimRequest(); +} + +void Trim11::trim() +{ + if (!mRenderer) + { + return; + } + +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + ID3D11Device *device = mRenderer->getDevice(); + IDXGIDevice3 *dxgiDevice3 = d3d11::DynamicCastComObject<IDXGIDevice3>(device); + if (dxgiDevice3) + { + dxgiDevice3->Trim(); + } + SafeRelease(dxgiDevice3); +#endif +} + +bool Trim11::registerForRendererTrimRequest() +{ +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + ICoreApplication *coreApplication = nullptr; + HRESULT result = GetActivationFactory( + HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(), + &coreApplication); + if (SUCCEEDED(result)) + { + auto suspendHandler = Callback<IEventHandler<SuspendingEventArgs *>>( + [this](IInspectable *, ISuspendingEventArgs *) -> HRESULT { + trim(); + return S_OK; + }); + result = + coreApplication->add_Suspending(suspendHandler.Get(), &mApplicationSuspendedEventToken); + } + SafeRelease(coreApplication); + + if (FAILED(result)) + { + return false; + } +#endif + return true; +} + +void Trim11::unregisterForRendererTrimRequest() +{ +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + if (mApplicationSuspendedEventToken.value != 0) + { + ICoreApplication *coreApplication = nullptr; + if (SUCCEEDED(GetActivationFactory( + HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(), + &coreApplication))) + { + coreApplication->remove_Suspending(mApplicationSuspendedEventToken); + } + mApplicationSuspendedEventToken.value = 0; + SafeRelease(coreApplication); + } +#endif +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.h new file mode 100644 index 0000000000..eb1f3e7e13 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/Trim11.h @@ -0,0 +1,43 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Trim11.h: Trim support utility class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TRIM11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TRIM11_H_ + +#include "common/angleutils.h" +#include "libANGLE/Error.h" +#include "libANGLE/angletypes.h" + +#if defined(ANGLE_ENABLE_WINDOWS_UWP) +# include <EventToken.h> +#endif + +namespace rx +{ +class Renderer11; + +class Trim11 : angle::NonCopyable +{ + public: + explicit Trim11(Renderer11 *renderer); + ~Trim11(); + + private: + Renderer11 *mRenderer; +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + EventRegistrationToken mApplicationSuspendedEventToken; +#endif + + void trim(); + bool registerForRendererTrimRequest(); + void unregisterForRendererTrimRequest(); +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TRIM11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp new file mode 100644 index 0000000000..a5f8b6a176 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp @@ -0,0 +1,375 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// VertexArray11: +// Implementation of rx::VertexArray11. +// + +#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" + +#include "common/bitset_utils.h" +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/IndexBuffer.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" + +using namespace angle; + +namespace rx +{ +VertexArray11::VertexArray11(const gl::VertexArrayState &data) + : VertexArrayImpl(data), + mAttributeStorageTypes(data.getMaxAttribs(), VertexStorageType::CURRENT_VALUE), + mTranslatedAttribs(data.getMaxAttribs()), + mAppliedNumViewsToDivisor(1), + mCurrentElementArrayStorage(IndexStorageType::Invalid), + mCachedDestinationIndexType(gl::DrawElementsType::InvalidEnum) +{} + +VertexArray11::~VertexArray11() {} + +void VertexArray11::destroy(const gl::Context *context) {} + +// As VertexAttribPointer can modify both attribute and binding, we should also set other attributes +// that are also using this binding dirty. +#define ANGLE_VERTEX_DIRTY_ATTRIB_FUNC(INDEX) \ + case gl::VertexArray::DIRTY_BIT_ATTRIB_0 + INDEX: \ + if ((*attribBits)[INDEX][gl::VertexArray::DirtyAttribBitType::DIRTY_ATTRIB_POINTER]) \ + { \ + attributesToUpdate |= mState.getBindingToAttributesMask(INDEX); \ + } \ + else \ + { \ + attributesToUpdate.set(INDEX); \ + } \ + invalidateVertexBuffer = true; \ + (*attribBits)[INDEX].reset(); \ + break; + +#define ANGLE_VERTEX_DIRTY_BINDING_FUNC(INDEX) \ + case gl::VertexArray::DIRTY_BIT_BINDING_0 + INDEX: \ + attributesToUpdate |= mState.getBindingToAttributesMask(INDEX); \ + invalidateVertexBuffer = true; \ + (*bindingBits)[INDEX].reset(); \ + break; + +#define ANGLE_VERTEX_DIRTY_BUFFER_DATA_FUNC(INDEX) \ + case gl::VertexArray::DIRTY_BIT_BUFFER_DATA_0 + INDEX: \ + if (mAttributeStorageTypes[INDEX] == VertexStorageType::STATIC) \ + { \ + invalidateVertexBuffer = true; \ + mAttribsToTranslate.set(INDEX); \ + } \ + break; + +angle::Result VertexArray11::syncState(const gl::Context *context, + const gl::VertexArray::DirtyBits &dirtyBits, + gl::VertexArray::DirtyAttribBitsArray *attribBits, + gl::VertexArray::DirtyBindingBitsArray *bindingBits) +{ + ASSERT(dirtyBits.any()); + + Renderer11 *renderer = GetImplAs<Context11>(context)->getRenderer(); + StateManager11 *stateManager = renderer->getStateManager(); + + // Generate a state serial. This serial is used in the program class to validate the cached + // input layout, and skip recomputation in the fast path. + mCurrentStateSerial = renderer->generateSerial(); + + bool invalidateVertexBuffer = false; + + gl::AttributesMask attributesToUpdate; + + // Make sure we trigger re-translation for static index or vertex data. + for (size_t dirtyBit : dirtyBits) + { + switch (dirtyBit) + { + case gl::VertexArray::DIRTY_BIT_ELEMENT_ARRAY_BUFFER: + case gl::VertexArray::DIRTY_BIT_ELEMENT_ARRAY_BUFFER_DATA: + { + mLastDrawElementsType.reset(); + mLastDrawElementsIndices.reset(); + mLastPrimitiveRestartEnabled.reset(); + mCachedIndexInfo.reset(); + break; + } + + ANGLE_VERTEX_INDEX_CASES(ANGLE_VERTEX_DIRTY_ATTRIB_FUNC) + ANGLE_VERTEX_INDEX_CASES(ANGLE_VERTEX_DIRTY_BINDING_FUNC) + ANGLE_VERTEX_INDEX_CASES(ANGLE_VERTEX_DIRTY_BUFFER_DATA_FUNC) + + default: + UNREACHABLE(); + break; + } + } + + for (size_t attribIndex : attributesToUpdate) + { + updateVertexAttribStorage(context, stateManager, attribIndex); + } + + if (invalidateVertexBuffer) + { + // TODO(jmadill): Individual attribute invalidation. + stateManager->invalidateVertexBuffer(); + } + + return angle::Result::Continue; +} + +angle::Result VertexArray11::syncStateForDraw(const gl::Context *context, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic) +{ + Renderer11 *renderer = GetImplAs<Context11>(context)->getRenderer(); + StateManager11 *stateManager = renderer->getStateManager(); + + const gl::State &glState = context->getState(); + const gl::Program *program = glState.getProgram(); + ASSERT(program); + const gl::ProgramExecutable &executable = program->getExecutable(); + + mAppliedNumViewsToDivisor = (program->usesMultiview() ? program->getNumViews() : 1); + + if (mAttribsToTranslate.any()) + { + const gl::AttributesMask &activeLocations = executable.getActiveAttribLocationsMask(); + gl::AttributesMask activeDirtyAttribs = (mAttribsToTranslate & activeLocations); + if (activeDirtyAttribs.any()) + { + ANGLE_TRY(updateDirtyAttribs(context, activeDirtyAttribs)); + stateManager->invalidateInputLayout(); + } + } + + if (mDynamicAttribsMask.any()) + { + const gl::AttributesMask &activeLocations = executable.getActiveAttribLocationsMask(); + gl::AttributesMask activeDynamicAttribs = (mDynamicAttribsMask & activeLocations); + + if (activeDynamicAttribs.any()) + { + ANGLE_TRY(updateDynamicAttribs(context, stateManager->getVertexDataManager(), + firstVertex, vertexOrIndexCount, indexTypeOrInvalid, + indices, instances, baseVertex, baseInstance, + promoteDynamic, activeDynamicAttribs)); + stateManager->invalidateInputLayout(); + } + } + + if (indexTypeOrInvalid != gl::DrawElementsType::InvalidEnum) + { + bool restartEnabled = context->getState().isPrimitiveRestartEnabled(); + if (!mLastDrawElementsType.valid() || mLastDrawElementsType.value() != indexTypeOrInvalid || + mLastDrawElementsIndices.value() != indices || + mLastPrimitiveRestartEnabled.value() != restartEnabled) + { + mLastDrawElementsType = indexTypeOrInvalid; + mLastDrawElementsIndices = indices; + mLastPrimitiveRestartEnabled = restartEnabled; + + ANGLE_TRY(updateElementArrayStorage(context, vertexOrIndexCount, indexTypeOrInvalid, + indices, restartEnabled)); + stateManager->invalidateIndexBuffer(); + } + else if (mCurrentElementArrayStorage == IndexStorageType::Dynamic) + { + stateManager->invalidateIndexBuffer(); + } + } + + return angle::Result::Continue; +} + +angle::Result VertexArray11::updateElementArrayStorage(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + bool restartEnabled) +{ + bool usePrimitiveRestartWorkaround = UsePrimitiveRestartWorkaround(restartEnabled, indexType); + + ANGLE_TRY(GetIndexTranslationDestType(context, indexCount, indexType, indices, + usePrimitiveRestartWorkaround, + &mCachedDestinationIndexType)); + + unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices)); + + mCurrentElementArrayStorage = + ClassifyIndexStorage(context->getState(), mState.getElementArrayBuffer(), indexType, + mCachedDestinationIndexType, offset); + + return angle::Result::Continue; +} + +void VertexArray11::updateVertexAttribStorage(const gl::Context *context, + StateManager11 *stateManager, + size_t attribIndex) +{ + const gl::VertexAttribute &attrib = mState.getVertexAttribute(attribIndex); + const gl::VertexBinding &binding = mState.getBindingFromAttribIndex(attribIndex); + + VertexStorageType newStorageType = ClassifyAttributeStorage(context, attrib, binding); + + // Note: having an unchanged storage type doesn't mean the attribute is clean. + mAttribsToTranslate.set(attribIndex, newStorageType != VertexStorageType::DYNAMIC); + + if (mAttributeStorageTypes[attribIndex] == newStorageType) + return; + + mAttributeStorageTypes[attribIndex] = newStorageType; + mDynamicAttribsMask.set(attribIndex, newStorageType == VertexStorageType::DYNAMIC); + + if (newStorageType == VertexStorageType::CURRENT_VALUE) + { + stateManager->invalidateCurrentValueAttrib(attribIndex); + } +} + +bool VertexArray11::hasActiveDynamicAttrib(const gl::Context *context) +{ + const auto &activeLocations = + context->getState().getProgramExecutable()->getActiveAttribLocationsMask(); + gl::AttributesMask activeDynamicAttribs = (mDynamicAttribsMask & activeLocations); + return activeDynamicAttribs.any(); +} + +angle::Result VertexArray11::updateDirtyAttribs(const gl::Context *context, + const gl::AttributesMask &activeDirtyAttribs) +{ + const auto &glState = context->getState(); + const auto &attribs = mState.getVertexAttributes(); + const auto &bindings = mState.getVertexBindings(); + + for (size_t dirtyAttribIndex : activeDirtyAttribs) + { + auto *translatedAttrib = &mTranslatedAttribs[dirtyAttribIndex]; + const auto ¤tValue = glState.getVertexAttribCurrentValue(dirtyAttribIndex); + + // Record basic attrib info + translatedAttrib->attribute = &attribs[dirtyAttribIndex]; + translatedAttrib->binding = &bindings[translatedAttrib->attribute->bindingIndex]; + translatedAttrib->currentValueType = currentValue.Type; + translatedAttrib->divisor = + translatedAttrib->binding->getDivisor() * mAppliedNumViewsToDivisor; + + switch (mAttributeStorageTypes[dirtyAttribIndex]) + { + case VertexStorageType::DIRECT: + VertexDataManager::StoreDirectAttrib(context, translatedAttrib); + break; + case VertexStorageType::STATIC: + { + ANGLE_TRY(VertexDataManager::StoreStaticAttrib(context, translatedAttrib)); + break; + } + case VertexStorageType::CURRENT_VALUE: + // Current value attribs are managed by the StateManager11. + break; + default: + UNREACHABLE(); + break; + } + + // Make sure we reset the dirty bit after the switch because STATIC can early exit. + mAttribsToTranslate.reset(dirtyAttribIndex); + } + + return angle::Result::Continue; +} + +angle::Result VertexArray11::updateDynamicAttribs(const gl::Context *context, + VertexDataManager *vertexDataManager, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic, + const gl::AttributesMask &activeDynamicAttribs) +{ + const auto &glState = context->getState(); + const auto &attribs = mState.getVertexAttributes(); + const auto &bindings = mState.getVertexBindings(); + + GLint startVertex; + size_t vertexCount; + ANGLE_TRY(GetVertexRangeInfo(context, firstVertex, vertexOrIndexCount, indexTypeOrInvalid, + indices, baseVertex, &startVertex, &vertexCount)); + + for (size_t dynamicAttribIndex : activeDynamicAttribs) + { + auto *dynamicAttrib = &mTranslatedAttribs[dynamicAttribIndex]; + const auto ¤tValue = glState.getVertexAttribCurrentValue(dynamicAttribIndex); + + // Record basic attrib info + dynamicAttrib->attribute = &attribs[dynamicAttribIndex]; + dynamicAttrib->binding = &bindings[dynamicAttrib->attribute->bindingIndex]; + dynamicAttrib->currentValueType = currentValue.Type; + dynamicAttrib->divisor = dynamicAttrib->binding->getDivisor() * mAppliedNumViewsToDivisor; + } + + ANGLE_TRY(vertexDataManager->storeDynamicAttribs(context, &mTranslatedAttribs, + activeDynamicAttribs, startVertex, vertexCount, + instances, baseInstance)); + + if (promoteDynamic) + { + VertexDataManager::PromoteDynamicAttribs(context, mTranslatedAttribs, activeDynamicAttribs, + vertexCount); + } + + return angle::Result::Continue; +} + +const std::vector<TranslatedAttribute> &VertexArray11::getTranslatedAttribs() const +{ + return mTranslatedAttribs; +} + +void VertexArray11::markAllAttributeDivisorsForAdjustment(int numViews) +{ + if (mAppliedNumViewsToDivisor != numViews) + { + mAppliedNumViewsToDivisor = numViews; + mAttribsToTranslate.set(); + // mDynamicAttribsMask may have already been set (updateVertexAttribStorage + // We don't want to override DYNAMIC attribs as they will be handled separately. + mAttribsToTranslate = mAttribsToTranslate ^ mDynamicAttribsMask; + } +} + +const TranslatedIndexData &VertexArray11::getCachedIndexInfo() const +{ + ASSERT(mCachedIndexInfo.valid()); + return mCachedIndexInfo.value(); +} + +void VertexArray11::updateCachedIndexInfo(const TranslatedIndexData &indexInfo) +{ + mCachedIndexInfo = indexInfo; +} + +bool VertexArray11::isCachedIndexInfoValid() const +{ + return mCachedIndexInfo.valid(); +} + +gl::DrawElementsType VertexArray11::getCachedDestinationIndexType() const +{ + return mCachedDestinationIndexType; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h new file mode 100644 index 0000000000..a0ac5d74f1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h @@ -0,0 +1,112 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexArray11.h: Defines the rx::VertexArray11 class which implements rx::VertexArrayImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_VERTEXARRAY11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_VERTEXARRAY11_H_ + +#include "libANGLE/Framebuffer.h" +#include "libANGLE/renderer/VertexArrayImpl.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ +class Renderer11; + +class VertexArray11 : public VertexArrayImpl +{ + public: + VertexArray11(const gl::VertexArrayState &data); + ~VertexArray11() override; + void destroy(const gl::Context *context) override; + + // Does not apply any state updates - these are done in syncStateForDraw which as access to + // the draw call parameters. + angle::Result syncState(const gl::Context *context, + const gl::VertexArray::DirtyBits &dirtyBits, + gl::VertexArray::DirtyAttribBitsArray *attribBits, + gl::VertexArray::DirtyBindingBitsArray *bindingBits) override; + + // Applied buffer pointers are updated here. + angle::Result syncStateForDraw(const gl::Context *context, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic); + + // This will check the dynamic attribs mask. + bool hasActiveDynamicAttrib(const gl::Context *context); + + const std::vector<TranslatedAttribute> &getTranslatedAttribs() const; + + Serial getCurrentStateSerial() const { return mCurrentStateSerial; } + + // In case of a multi-view program change, we have to update all attributes so that the divisor + // is adjusted. + void markAllAttributeDivisorsForAdjustment(int numViews); + + const TranslatedIndexData &getCachedIndexInfo() const; + void updateCachedIndexInfo(const TranslatedIndexData &indexInfo); + bool isCachedIndexInfoValid() const; + + gl::DrawElementsType getCachedDestinationIndexType() const; + + private: + void updateVertexAttribStorage(const gl::Context *context, + StateManager11 *stateManager, + size_t attribIndex); + angle::Result updateDirtyAttribs(const gl::Context *context, + const gl::AttributesMask &activeDirtyAttribs); + angle::Result updateDynamicAttribs(const gl::Context *context, + VertexDataManager *vertexDataManager, + GLint firstVertex, + GLsizei vertexOrIndexCount, + gl::DrawElementsType indexTypeOrInvalid, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance, + bool promoteDynamic, + const gl::AttributesMask &activeDynamicAttribs); + + angle::Result updateElementArrayStorage(const gl::Context *context, + GLsizei indexCount, + gl::DrawElementsType indexType, + const void *indices, + bool restartEnabled); + + std::vector<VertexStorageType> mAttributeStorageTypes; + std::vector<TranslatedAttribute> mTranslatedAttribs; + + // The mask of attributes marked as dynamic. + gl::AttributesMask mDynamicAttribsMask; + + // A set of attributes we know are dirty, and need to be re-translated. + gl::AttributesMask mAttribsToTranslate; + + Serial mCurrentStateSerial; + + // The numViews value used to adjust the divisor. + int mAppliedNumViewsToDivisor; + + // If the index buffer needs re-streaming. + Optional<gl::DrawElementsType> mLastDrawElementsType; + Optional<const void *> mLastDrawElementsIndices; + Optional<bool> mLastPrimitiveRestartEnabled; + IndexStorageType mCurrentElementArrayStorage; + Optional<TranslatedIndexData> mCachedIndexInfo; + gl::DrawElementsType mCachedDestinationIndexType; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_VERTEXARRAY11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp new file mode 100644 index 0000000000..9daa8f83f9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp @@ -0,0 +1,167 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer11.cpp: Defines the D3D11 VertexBuffer implementation. + +#include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h" + +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +namespace rx +{ + +VertexBuffer11::VertexBuffer11(Renderer11 *const renderer) + : mRenderer(renderer), + mBuffer(), + mBufferSize(0), + mDynamicUsage(false), + mMappedResourceData(nullptr) +{} + +VertexBuffer11::~VertexBuffer11() +{ + ASSERT(mMappedResourceData == nullptr); +} + +angle::Result VertexBuffer11::initialize(const gl::Context *context, + unsigned int size, + bool dynamicUsage) +{ + mBuffer.reset(); + updateSerial(); + + if (size > 0) + { + D3D11_BUFFER_DESC bufferDesc; + bufferDesc.ByteWidth = size; + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + bufferDesc.MiscFlags = 0; + bufferDesc.StructureByteStride = 0; + + ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &mBuffer)); + + if (dynamicUsage) + { + mBuffer.setInternalName("VertexBuffer11(dynamic)"); + } + else + { + mBuffer.setInternalName("VertexBuffer11(static)"); + } + } + + mBufferSize = size; + mDynamicUsage = dynamicUsage; + + return angle::Result::Continue; +} + +angle::Result VertexBuffer11::mapResource(const gl::Context *context) +{ + if (mMappedResourceData == nullptr) + { + D3D11_MAPPED_SUBRESOURCE mappedResource; + + ANGLE_TRY(mRenderer->mapResource(context, mBuffer.get(), 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, + &mappedResource)); + + mMappedResourceData = static_cast<uint8_t *>(mappedResource.pData); + } + + return angle::Result::Continue; +} + +void VertexBuffer11::hintUnmapResource() +{ + if (mMappedResourceData != nullptr) + { + ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext(); + dxContext->Unmap(mBuffer.get(), 0); + + mMappedResourceData = nullptr; + } +} + +angle::Result VertexBuffer11::storeVertexAttributes(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + unsigned int offset, + const uint8_t *sourceData) +{ + ASSERT(mBuffer.valid()); + + int inputStride = static_cast<int>(ComputeVertexAttributeStride(attrib, binding)); + + // This will map the resource if it isn't already mapped. + ANGLE_TRY(mapResource(context)); + + uint8_t *output = mMappedResourceData + offset; + + const uint8_t *input = sourceData; + + if (instances == 0 || binding.getDivisor() == 0) + { + input += inputStride * start; + } + + angle::FormatID vertexFormatID = gl::GetVertexFormatID(attrib, currentValueType); + const D3D_FEATURE_LEVEL featureLevel = mRenderer->getRenderer11DeviceCaps().featureLevel; + const d3d11::VertexFormat &vertexFormatInfo = + d3d11::GetVertexFormatInfo(vertexFormatID, featureLevel); + ASSERT(vertexFormatInfo.copyFunction != nullptr); + vertexFormatInfo.copyFunction(input, inputStride, count, output); + + return angle::Result::Continue; +} + +unsigned int VertexBuffer11::getBufferSize() const +{ + return mBufferSize; +} + +angle::Result VertexBuffer11::setBufferSize(const gl::Context *context, unsigned int size) +{ + if (size > mBufferSize) + { + return initialize(context, size, mDynamicUsage); + } + + return angle::Result::Continue; +} + +angle::Result VertexBuffer11::discard(const gl::Context *context) +{ + ASSERT(mBuffer.valid()); + + D3D11_MAPPED_SUBRESOURCE mappedResource; + ANGLE_TRY(mRenderer->mapResource(context, mBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, + &mappedResource)); + + mRenderer->getDeviceContext()->Unmap(mBuffer.get(), 0); + + return angle::Result::Continue; +} + +const d3d11::Buffer &VertexBuffer11::getBuffer() const +{ + return mBuffer; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h new file mode 100644 index 0000000000..46b52cb602 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h @@ -0,0 +1,65 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer11.h: Defines the D3D11 VertexBuffer implementation. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_VERTEXBUFFER11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_VERTEXBUFFER11_H_ + +#include <stdint.h> + +#include "libANGLE/renderer/d3d/VertexBuffer.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" + +namespace rx +{ +class Renderer11; + +class VertexBuffer11 : public VertexBuffer +{ + public: + explicit VertexBuffer11(Renderer11 *const renderer); + + angle::Result initialize(const gl::Context *context, + unsigned int size, + bool dynamicUsage) override; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + angle::Result storeVertexAttributes(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + unsigned int offset, + const uint8_t *sourceData) override; + + unsigned int getBufferSize() const override; + angle::Result setBufferSize(const gl::Context *context, unsigned int size) override; + angle::Result discard(const gl::Context *context) override; + + void hintUnmapResource() override; + + const d3d11::Buffer &getBuffer() const; + + private: + ~VertexBuffer11() override; + angle::Result mapResource(const gl::Context *context); + + Renderer11 *const mRenderer; + + d3d11::Buffer mBuffer; + unsigned int mBufferSize; + bool mDynamicUsage; + + uint8_t *mMappedResourceData; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_VERTEXBUFFER11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.cpp new file mode 100644 index 0000000000..0e64f78d53 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.cpp @@ -0,0 +1,457 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// CompositorNativeWindow11.cpp: Implementation of NativeWindow11 using Windows.UI.Composition APIs +// which work in both Win32 and WinRT contexts. + +#include "libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include "common/debug.h" + +using namespace Microsoft::WRL; + +namespace rx +{ + +CompositorNativeWindow11::CompositorNativeWindow11(EGLNativeWindowType window, bool hasAlpha) + : NativeWindow11(window), mHasAlpha(hasAlpha) +{ + ABI::Windows::UI::Composition::ISpriteVisual *inspPtr = + reinterpret_cast<ABI::Windows::UI::Composition::ISpriteVisual *>(window); + mHostVisual = Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ISpriteVisual>{inspPtr}; +} + +CompositorNativeWindow11::~CompositorNativeWindow11() = default; + +bool CompositorNativeWindow11::initialize() +{ + return true; +} + +bool CompositorNativeWindow11::getClientRect(LPRECT rect) const +{ + ComPtr<ABI::Windows::UI::Composition::IVisual> visual; + mHostVisual.As(&visual); + + ABI::Windows::Foundation::Numerics::Vector2 size; + HRESULT hr = visual->get_Size(&size); + if (FAILED(hr)) + { + return false; + } + + ABI::Windows::Foundation::Numerics::Vector3 offset; + hr = visual->get_Offset(&offset); + if (FAILED(hr)) + { + return false; + } + + rect->top = static_cast<LONG>(offset.Y); + rect->left = static_cast<LONG>(offset.X); + rect->right = static_cast<LONG>(offset.X) + static_cast<LONG>(size.X); + rect->bottom = static_cast<LONG>(offset.Y) + static_cast<LONG>(size.Y); + + return true; +} + +bool CompositorNativeWindow11::isIconic() const +{ + return false; +} + +HRESULT CompositorNativeWindow11::createSwapChain(ID3D11Device *device, + IDXGIFactory *factory, + DXGI_FORMAT format, + UINT width, + UINT height, + UINT samples, + IDXGISwapChain **swapChain) +{ + if (device == nullptr || factory == nullptr || swapChain == nullptr || width == 0 || + height == 0) + { + return E_INVALIDARG; + } + + HRESULT hr{E_FAIL}; + + ComPtr<ABI::Windows::UI::Composition::ICompositionObject> hostVisual; + hr = mHostVisual.As(&hostVisual); + if (FAILED(hr)) + { + return hr; + } + + Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ICompositor> compositor; + hr = hostVisual->get_Compositor(&compositor); + if (FAILED(hr)) + { + return hr; + } + + ComPtr<ABI::Windows::UI::Composition::ICompositorInterop> interop; + + hr = compositor.As(&interop); + if (FAILED(hr)) + { + return hr; + } + + ComPtr<IDXGIFactory2> factory2; + factory2.Attach(d3d11::DynamicCastComObject<IDXGIFactory2>(factory)); + + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {}; + swapChainDesc.Width = width; + swapChainDesc.Height = height; + swapChainDesc.Format = format; + swapChainDesc.Stereo = FALSE; + swapChainDesc.SampleDesc.Count = 1; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.BufferUsage = + DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_SHADER_INPUT; + swapChainDesc.BufferCount = 2; + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + swapChainDesc.AlphaMode = mHasAlpha ? DXGI_ALPHA_MODE_PREMULTIPLIED : DXGI_ALPHA_MODE_IGNORE; +#ifndef ANGLE_ENABLE_WINDOWS_UWP + swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG::DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT; +#endif + Microsoft::WRL::ComPtr<IDXGISwapChain1> swapChain1; + hr = factory2->CreateSwapChainForComposition(device, &swapChainDesc, nullptr, &swapChain1); + if (SUCCEEDED(hr)) + { + swapChain1.CopyTo(swapChain); + } + + hr = interop->CreateCompositionSurfaceForSwapChain(swapChain1.Get(), &mSurface); + if (FAILED(hr)) + { + return hr; + } + + hr = compositor->CreateSurfaceBrushWithSurface(mSurface.Get(), &mSurfaceBrush); + if (FAILED(hr)) + { + return hr; + } + + hr = mSurfaceBrush.As(&mCompositionBrush); + if (FAILED(hr)) + { + return hr; + } + + hr = mHostVisual->put_Brush(mCompositionBrush.Get()); + if (FAILED(hr)) + { + return hr; + } + + return hr; +} + +void CompositorNativeWindow11::commitChange() +{ + // Windows::UI::Composition uses an implicit commit model hence no action needed here +} + +// static +bool CompositorNativeWindow11::IsValidNativeWindow(EGLNativeWindowType window) +{ + return IsSupportedWinRelease() && IsSpriteVisual(window); +} + +// static +bool CompositorNativeWindow11::IsSupportedWinRelease() +{ + RoHelper helper; + if (!helper.WinRtAvailable()) + { + return false; + } + + return helper.SupportedWindowsRelease(); +} + +bool CompositorNativeWindow11::IsSpriteVisual(EGLNativeWindowType window) +{ + RoHelper helper; + + ABI::Windows::UI::Composition::ISpriteVisual *inspp = + reinterpret_cast<ABI::Windows::UI::Composition::ISpriteVisual *>(window); + HSTRING className, spriteClassName; + HSTRING_HEADER spriteClassNameHeader; + + auto hr = helper.GetStringReference(RuntimeClass_Windows_UI_Composition_SpriteVisual, + &spriteClassName, &spriteClassNameHeader); + if (FAILED(hr)) + { + return false; + } + + hr = inspp->GetRuntimeClassName(&className); + if (FAILED(hr)) + { + return false; + } + + INT32 result = -1; + hr = helper.WindowsCompareStringOrdinal(className, spriteClassName, &result); + + helper.WindowsDeleteString(className); + + if (FAILED(hr)) + { + return false; + } + + if (result == 0) + { + return true; + } + + return false; +} + +// RoHelperImpl + +template <typename T> +bool AssignProcAddress(HMODULE comBaseModule, const char *name, T *&outProc) +{ + outProc = reinterpret_cast<T *>(GetProcAddress(comBaseModule, name)); + return *outProc != nullptr; +} + +RoHelper::RoHelper() + : mFpWindowsCreateStringReference(nullptr), + mFpGetActivationFactory(nullptr), + mFpWindowsCompareStringOrdinal(nullptr), + mFpCreateDispatcherQueueController(nullptr), + mFpWindowsDeleteString(nullptr), + mFpRoInitialize(nullptr), + mFpRoUninitialize(nullptr), + mWinRtAvailable(false), + mWinRtInitialized(false), + mComBaseModule(nullptr), + mCoreMessagingModule(nullptr) +{ + +#ifdef ANGLE_ENABLE_WINDOWS_UWP + mFpWindowsCreateStringReference = &::WindowsCreateStringReference; + mFpRoInitialize = &::RoInitialize; + mFpRoUninitialize = &::RoUninitialize; + mFpWindowsDeleteString = &::WindowsDeleteString; + mFpGetActivationFactory = &::RoGetActivationFactory; + mFpWindowsCompareStringOrdinal = &::WindowsCompareStringOrdinal; + mFpCreateDispatcherQueueController = &::CreateDispatcherQueueController; + mWinRtAvailable = true; +#else + + mComBaseModule = LoadLibraryA("ComBase.dll"); + + if (mComBaseModule == nullptr) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "WindowsCreateStringReference", + mFpWindowsCreateStringReference)) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "RoGetActivationFactory", mFpGetActivationFactory)) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "WindowsCompareStringOrdinal", + mFpWindowsCompareStringOrdinal)) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "WindowsDeleteString", mFpWindowsDeleteString)) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "RoInitialize", mFpRoInitialize)) + { + return; + } + + if (!AssignProcAddress(mComBaseModule, "RoUninitialize", mFpRoUninitialize)) + { + return; + } + + mCoreMessagingModule = LoadLibraryA("coremessaging.dll"); + + if (mCoreMessagingModule == nullptr) + { + return; + } + + if (!AssignProcAddress(mCoreMessagingModule, "CreateDispatcherQueueController", + mFpCreateDispatcherQueueController)) + { + return; + } + + auto result = RoInitialize(RO_INIT_MULTITHREADED); + + if (SUCCEEDED(result) || result == RPC_E_CHANGED_MODE) + { + mWinRtAvailable = true; + + if (SUCCEEDED(result)) + { + mWinRtInitialized = true; + } + } +#endif +} + +RoHelper::~RoHelper() +{ +#ifndef ANGLE_ENABLE_WINDOWS_UWP + if (mWinRtInitialized) + { + RoUninitialize(); + } + + if (mCoreMessagingModule != nullptr) + { + FreeLibrary(mCoreMessagingModule); + mCoreMessagingModule = nullptr; + } + + if (mComBaseModule != nullptr) + { + FreeLibrary(mComBaseModule); + mComBaseModule = nullptr; + } +#endif +} + +bool RoHelper::WinRtAvailable() const +{ + return mWinRtAvailable; +} + +bool RoHelper::SupportedWindowsRelease() +{ + if (!mWinRtAvailable) + { + return false; + } + + HSTRING className, contractName; + HSTRING_HEADER classNameHeader, contractNameHeader; + boolean isSupported = false; + + HRESULT hr = GetStringReference(RuntimeClass_Windows_Foundation_Metadata_ApiInformation, + &className, &classNameHeader); + + if (FAILED(hr)) + { + return !!isSupported; + } + + Microsoft::WRL::ComPtr<ABI::Windows::Foundation::Metadata::IApiInformationStatics> api; + + hr = GetActivationFactory( + className, __uuidof(ABI::Windows::Foundation::Metadata::IApiInformationStatics), &api); + + if (FAILED(hr)) + { + return !!isSupported; + } + + hr = GetStringReference(L"Windows.Foundation.UniversalApiContract", &contractName, + &contractNameHeader); + if (FAILED(hr)) + { + return !!isSupported; + } + + api->IsApiContractPresentByMajor(contractName, 6, &isSupported); + + return !!isSupported; +} + +HRESULT RoHelper::GetStringReference(PCWSTR source, HSTRING *act, HSTRING_HEADER *header) +{ + if (!mWinRtAvailable) + { + return E_FAIL; + } + + const wchar_t *str = static_cast<const wchar_t *>(source); + + unsigned int length; + HRESULT hr = SizeTToUInt32(::wcslen(str), &length); + if (FAILED(hr)) + { + return hr; + } + + return mFpWindowsCreateStringReference(source, length, header, act); +} + +HRESULT RoHelper::GetActivationFactory(const HSTRING act, const IID &interfaceId, void **fac) +{ + if (!mWinRtAvailable) + { + return E_FAIL; + } + auto hr = mFpGetActivationFactory(act, interfaceId, fac); + return hr; +} + +HRESULT RoHelper::WindowsCompareStringOrdinal(HSTRING one, HSTRING two, int *result) +{ + if (!mWinRtAvailable) + { + return E_FAIL; + } + return mFpWindowsCompareStringOrdinal(one, two, result); +} + +HRESULT RoHelper::CreateDispatcherQueueController( + DispatcherQueueOptions options, + ABI::Windows::System::IDispatcherQueueController **dispatcherQueueController) +{ + if (!mWinRtAvailable) + { + return E_FAIL; + } + return mFpCreateDispatcherQueueController(options, dispatcherQueueController); +} + +HRESULT RoHelper::WindowsDeleteString(HSTRING one) +{ + if (!mWinRtAvailable) + { + return E_FAIL; + } + return mFpWindowsDeleteString(one); +} + +HRESULT RoHelper::RoInitialize(RO_INIT_TYPE type) +{ + return mFpRoInitialize(type); +} + +void RoHelper::RoUninitialize() +{ + mFpRoUninitialize(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.h new file mode 100644 index 0000000000..82857322e0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/converged/CompositorNativeWindow11.h @@ -0,0 +1,116 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// CompositorNativeWindow11.h: Implementation of NativeWindow11 using Windows.UI.Composition APIs +// which work in both Win32 and WinRT contexts. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_CONVERGED_COMPOSITORNATIVEWINDOW11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_CONVERGED_COMPOSITORNATIVEWINDOW11_H_ + +#include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h" + +#include <dispatcherqueue.h> +#include <versionhelpers.h> +#include <windows.foundation.metadata.h> +#include <windows.ui.composition.h> +#include <windows.ui.composition.interop.h> +#include <wrl.h> + +namespace rx +{ + +class RoHelper +{ + public: + RoHelper(); + ~RoHelper(); + bool WinRtAvailable() const; + bool SupportedWindowsRelease(); + HRESULT GetStringReference(PCWSTR source, HSTRING *act, HSTRING_HEADER *header); + HRESULT GetActivationFactory(const HSTRING act, const IID &interfaceId, void **fac); + HRESULT WindowsCompareStringOrdinal(HSTRING one, HSTRING two, int *result); + HRESULT CreateDispatcherQueueController( + DispatcherQueueOptions options, + ABI::Windows::System::IDispatcherQueueController **dispatcherQueueController); + HRESULT WindowsDeleteString(HSTRING one); + HRESULT RoInitialize(RO_INIT_TYPE type); + void RoUninitialize(); + + private: + using WindowsCreateStringReference_ = HRESULT __stdcall(PCWSTR, + UINT32, + HSTRING_HEADER *, + HSTRING *); + + using GetActivationFactory_ = HRESULT __stdcall(HSTRING, REFIID, void **); + + using WindowsCompareStringOrginal_ = HRESULT __stdcall(HSTRING, HSTRING, int *); + + using WindowsDeleteString_ = HRESULT __stdcall(HSTRING); + + using CreateDispatcherQueueController_ = + HRESULT __stdcall(DispatcherQueueOptions, + ABI::Windows::System::IDispatcherQueueController **); + + using RoInitialize_ = HRESULT __stdcall(RO_INIT_TYPE); + using RoUninitialize_ = void __stdcall(); + + WindowsCreateStringReference_ *mFpWindowsCreateStringReference; + GetActivationFactory_ *mFpGetActivationFactory; + WindowsCompareStringOrginal_ *mFpWindowsCompareStringOrdinal; + CreateDispatcherQueueController_ *mFpCreateDispatcherQueueController; + WindowsDeleteString_ *mFpWindowsDeleteString; + RoInitialize_ *mFpRoInitialize; + RoUninitialize_ *mFpRoUninitialize; + + bool mWinRtAvailable; + bool mWinRtInitialized; + + HMODULE mComBaseModule; + HMODULE mCoreMessagingModule; +}; + +class CompositorNativeWindow11 : public NativeWindow11 +{ + public: + CompositorNativeWindow11(EGLNativeWindowType window, bool hasAlpha); + ~CompositorNativeWindow11() override; + + bool initialize() override; + bool getClientRect(LPRECT rect) const override; + bool isIconic() const override; + + HRESULT createSwapChain(ID3D11Device *device, + IDXGIFactory *factory, + DXGI_FORMAT format, + UINT width, + UINT height, + UINT samples, + IDXGISwapChain **swapChain) override; + + void commitChange() override; + + static bool IsValidNativeWindow(EGLNativeWindowType window); + + static bool IsSupportedWinRelease(); + + private: + static bool IsSpriteVisual(EGLNativeWindowType window); + + bool mHasAlpha; + + RoHelper mRoHelper; + + // Namespace prefix required here for some reason despite using namespace + Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ISpriteVisual> mHostVisual; + Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ICompositionBrush> mCompositionBrush; + Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ICompositionSurface> mSurface; + Microsoft::WRL::ComPtr<ABI::Windows::UI::Composition::ICompositionSurfaceBrush> mSurfaceBrush; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_CONVERGED_COMPOSITORNATIVEWINDOW11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp new file mode 100644 index 0000000000..75ddbd9ea1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp @@ -0,0 +1,1029 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// formatutils11.cpp: Queries for GL image formats and their translations to D3D11 +// formats. + +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" + +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/copyvertex.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/dxgi_support_table.h" + +namespace rx +{ + +namespace d3d11 +{ + +bool SupportsMipGen(DXGI_FORMAT dxgiFormat, D3D_FEATURE_LEVEL featureLevel) +{ + const auto &support = GetDXGISupport(dxgiFormat, featureLevel); + ASSERT((support.optionallySupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) == 0); + return ((support.alwaysSupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) != 0); +} + +DXGIFormatSize::DXGIFormatSize(GLuint pixelBits, GLuint blockWidth, GLuint blockHeight) + : pixelBytes(pixelBits / 8), blockWidth(blockWidth), blockHeight(blockHeight) +{} + +const DXGIFormatSize &GetDXGIFormatSizeInfo(DXGI_FORMAT format) +{ + static const DXGIFormatSize sizeUnknown(0, 0, 0); + static const DXGIFormatSize size128(128, 1, 1); + static const DXGIFormatSize size96(96, 1, 1); + static const DXGIFormatSize size64(64, 1, 1); + static const DXGIFormatSize size32(32, 1, 1); + static const DXGIFormatSize size16(16, 1, 1); + static const DXGIFormatSize size8(8, 1, 1); + static const DXGIFormatSize sizeBC1(64, 4, 4); + static const DXGIFormatSize sizeBC2(128, 4, 4); + static const DXGIFormatSize sizeBC3(128, 4, 4); + static const DXGIFormatSize sizeBC4(64, 4, 4); + static const DXGIFormatSize sizeBC5(128, 4, 4); + static const DXGIFormatSize sizeBC6H(128, 4, 4); + static const DXGIFormatSize sizeBC7(128, 4, 4); + switch (format) + { + case DXGI_FORMAT_UNKNOWN: + return sizeUnknown; + case DXGI_FORMAT_R32G32B32A32_TYPELESS: + case DXGI_FORMAT_R32G32B32A32_FLOAT: + case DXGI_FORMAT_R32G32B32A32_UINT: + case DXGI_FORMAT_R32G32B32A32_SINT: + return size128; + case DXGI_FORMAT_R32G32B32_TYPELESS: + case DXGI_FORMAT_R32G32B32_FLOAT: + case DXGI_FORMAT_R32G32B32_UINT: + case DXGI_FORMAT_R32G32B32_SINT: + return size96; + case DXGI_FORMAT_R16G16B16A16_TYPELESS: + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R16G16B16A16_UNORM: + case DXGI_FORMAT_R16G16B16A16_UINT: + case DXGI_FORMAT_R16G16B16A16_SNORM: + case DXGI_FORMAT_R16G16B16A16_SINT: + case DXGI_FORMAT_R32G32_TYPELESS: + case DXGI_FORMAT_R32G32_FLOAT: + case DXGI_FORMAT_R32G32_UINT: + case DXGI_FORMAT_R32G32_SINT: + case DXGI_FORMAT_R32G8X24_TYPELESS: + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: + case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: + case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: + return size64; + case DXGI_FORMAT_R10G10B10A2_TYPELESS: + case DXGI_FORMAT_R10G10B10A2_UNORM: + case DXGI_FORMAT_R10G10B10A2_UINT: + case DXGI_FORMAT_R11G11B10_FLOAT: + case DXGI_FORMAT_R8G8B8A8_TYPELESS: + case DXGI_FORMAT_R8G8B8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + case DXGI_FORMAT_R8G8B8A8_UINT: + case DXGI_FORMAT_R8G8B8A8_SNORM: + case DXGI_FORMAT_R8G8B8A8_SINT: + case DXGI_FORMAT_R16G16_TYPELESS: + case DXGI_FORMAT_R16G16_FLOAT: + case DXGI_FORMAT_R16G16_UNORM: + case DXGI_FORMAT_R16G16_UINT: + case DXGI_FORMAT_R16G16_SNORM: + case DXGI_FORMAT_R16G16_SINT: + case DXGI_FORMAT_R32_TYPELESS: + case DXGI_FORMAT_D32_FLOAT: + case DXGI_FORMAT_R32_FLOAT: + case DXGI_FORMAT_R32_UINT: + case DXGI_FORMAT_R32_SINT: + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + return size32; + case DXGI_FORMAT_R8G8_TYPELESS: + case DXGI_FORMAT_R8G8_UNORM: + case DXGI_FORMAT_R8G8_UINT: + case DXGI_FORMAT_R8G8_SNORM: + case DXGI_FORMAT_R8G8_SINT: + case DXGI_FORMAT_R16_TYPELESS: + case DXGI_FORMAT_R16_FLOAT: + case DXGI_FORMAT_D16_UNORM: + case DXGI_FORMAT_R16_UNORM: + case DXGI_FORMAT_R16_UINT: + case DXGI_FORMAT_R16_SNORM: + case DXGI_FORMAT_R16_SINT: + return size16; + case DXGI_FORMAT_R8_TYPELESS: + case DXGI_FORMAT_R8_UNORM: + case DXGI_FORMAT_R8_UINT: + case DXGI_FORMAT_R8_SNORM: + case DXGI_FORMAT_R8_SINT: + case DXGI_FORMAT_A8_UNORM: + return size8; + case DXGI_FORMAT_R1_UNORM: + UNREACHABLE(); + return sizeUnknown; + case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: + case DXGI_FORMAT_R8G8_B8G8_UNORM: + case DXGI_FORMAT_G8R8_G8B8_UNORM: + return size32; + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC1_UNORM: + case DXGI_FORMAT_BC1_UNORM_SRGB: + return sizeBC1; + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC2_UNORM: + case DXGI_FORMAT_BC2_UNORM_SRGB: + return sizeBC2; + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC3_UNORM: + case DXGI_FORMAT_BC3_UNORM_SRGB: + return sizeBC3; + case DXGI_FORMAT_BC4_TYPELESS: + case DXGI_FORMAT_BC4_UNORM: + case DXGI_FORMAT_BC4_SNORM: + return sizeBC4; + case DXGI_FORMAT_BC5_TYPELESS: + case DXGI_FORMAT_BC5_UNORM: + case DXGI_FORMAT_BC5_SNORM: + return sizeBC5; + case DXGI_FORMAT_B5G6R5_UNORM: + case DXGI_FORMAT_B5G5R5A1_UNORM: + return size16; + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8X8_UNORM: + case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: + return size32; + case DXGI_FORMAT_BC6H_TYPELESS: + case DXGI_FORMAT_BC6H_UF16: + case DXGI_FORMAT_BC6H_SF16: + return sizeBC6H; + case DXGI_FORMAT_BC7_TYPELESS: + case DXGI_FORMAT_BC7_UNORM: + case DXGI_FORMAT_BC7_UNORM_SRGB: + return sizeBC7; + case DXGI_FORMAT_AYUV: + case DXGI_FORMAT_Y410: + case DXGI_FORMAT_Y416: + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + case DXGI_FORMAT_420_OPAQUE: + case DXGI_FORMAT_YUY2: + case DXGI_FORMAT_Y210: + case DXGI_FORMAT_Y216: + case DXGI_FORMAT_NV11: + case DXGI_FORMAT_AI44: + case DXGI_FORMAT_IA44: + case DXGI_FORMAT_P8: + case DXGI_FORMAT_A8P8: + UNREACHABLE(); + return sizeUnknown; + case DXGI_FORMAT_B4G4R4A4_UNORM: + return size16; + default: + UNREACHABLE(); + return sizeUnknown; + } +} + +constexpr VertexFormat::VertexFormat() + : conversionType(VERTEX_CONVERT_NONE), nativeFormat(DXGI_FORMAT_UNKNOWN), copyFunction(nullptr) +{} + +constexpr VertexFormat::VertexFormat(VertexConversionType conversionTypeIn, + DXGI_FORMAT nativeFormatIn, + VertexCopyFunction copyFunctionIn) + : conversionType(conversionTypeIn), nativeFormat(nativeFormatIn), copyFunction(copyFunctionIn) +{} + +const VertexFormat *GetVertexFormatInfo_FL_9_3(angle::FormatID vertexFormatID) +{ + // D3D11 Feature Level 9_3 doesn't support as many formats for vertex buffer resource as Feature + // Level 10_0+. + // http://msdn.microsoft.com/en-us/library/windows/desktop/ff471324(v=vs.85).aspx + + switch (vertexFormatID) + { + // GL_BYTE -- unnormalized + case angle::FormatID::R8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT, + &Copy8SintTo16SintVertexData<1, 2>); + return &info; + } + case angle::FormatID::R8G8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT, + &Copy8SintTo16SintVertexData<2, 2>); + return &info; + } + case angle::FormatID::R8G8B8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT, + &Copy8SintTo16SintVertexData<3, 4>); + return &info; + } + case angle::FormatID::R8G8B8A8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT, + &Copy8SintTo16SintVertexData<4, 4>); + return &info; + } + + // GL_BYTE -- normalized + case angle::FormatID::R8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM, + &Copy8SnormTo16SnormVertexData<1, 2>); + return &info; + } + case angle::FormatID::R8G8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM, + &Copy8SnormTo16SnormVertexData<2, 2>); + return &info; + } + case angle::FormatID::R8G8B8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM, + &Copy8SnormTo16SnormVertexData<3, 4>); + return &info; + } + case angle::FormatID::R8G8B8A8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM, + &Copy8SnormTo16SnormVertexData<4, 4>); + return &info; + } + + // GL_UNSIGNED_BYTE -- un-normalized + // NOTE: 3 and 4 component unnormalized GL_UNSIGNED_BYTE should use the default format + // table. + case angle::FormatID::R8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 1, 4, 1>); + return &info; + } + case angle::FormatID::R8G8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 2, 4, 1>); + return &info; + } + + // GL_UNSIGNED_BYTE -- normalized + // NOTE: 3 and 4 component normalized GL_UNSIGNED_BYTE should use the default format table. + + // GL_UNSIGNED_BYTE -- normalized + case angle::FormatID::R8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM, + &CopyNativeVertexData<GLubyte, 1, 4, UINT8_MAX>); + return &info; + } + case angle::FormatID::R8G8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM, + &CopyNativeVertexData<GLubyte, 2, 4, UINT8_MAX>); + return &info; + } + + // GL_SHORT -- un-normalized + // NOTE: 2, 3 and 4 component unnormalized GL_SHORT should use the default format table. + case angle::FormatID::R16_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT, + &CopyNativeVertexData<GLshort, 1, 2, 0>); + return &info; + } + + // GL_SHORT -- normalized + // NOTE: 2, 3 and 4 component normalized GL_SHORT should use the default format table. + case angle::FormatID::R16_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM, + &CopyNativeVertexData<GLshort, 1, 2, 0>); + return &info; + } + + // GL_UNSIGNED_SHORT -- un-normalized + case angle::FormatID::R16_USCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLushort, 1, 2, false, false>); + return &info; + } + case angle::FormatID::R16G16_USCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLushort, 2, 2, false, false>); + return &info; + } + case angle::FormatID::R16G16B16_USCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, + &CopyToFloatVertexData<GLushort, 3, 3, false, false>); + return &info; + } + case angle::FormatID::R16G16B16A16_USCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyToFloatVertexData<GLushort, 4, 4, false, false>); + return &info; + } + + // GL_UNSIGNED_SHORT -- normalized + case angle::FormatID::R16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLushort, 1, 2, true, false>); + return &info; + } + case angle::FormatID::R16G16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLushort, 2, 2, true, false>); + return &info; + } + case angle::FormatID::R16G16B16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, + &CopyToFloatVertexData<GLushort, 3, 3, true, false>); + return &info; + } + case angle::FormatID::R16G16B16A16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyToFloatVertexData<GLushort, 4, 4, true, false>); + return &info; + } + + // GL_FIXED + // TODO: Add test to verify that this works correctly. + // NOTE: 2, 3 and 4 component GL_FIXED should use the default format table. + case angle::FormatID::R32_FIXED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &Copy32FixedTo32FVertexData<1, 2>); + return &info; + } + + // GL_FLOAT + // TODO: Add test to verify that this works correctly. + // NOTE: 2, 3 and 4 component GL_FLOAT should use the default format table. + case angle::FormatID::R32_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyNativeVertexData<GLfloat, 1, 2, 0>); + return &info; + } + + default: + return nullptr; + } +} + +const VertexFormat &GetVertexFormatInfo(angle::FormatID vertexFormatID, + D3D_FEATURE_LEVEL featureLevel) +{ + if (featureLevel == D3D_FEATURE_LEVEL_9_3) + { + const VertexFormat *result = GetVertexFormatInfo_FL_9_3(vertexFormatID); + if (result) + { + return *result; + } + } + + switch (vertexFormatID) + { + // + // Float formats + // + + // GL_BYTE -- un-normalized + case angle::FormatID::R8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_SINT, + &CopyNativeVertexData<GLbyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_SINT, + &CopyNativeVertexData<GLbyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_SINT, + &CopyNativeVertexData<GLbyte, 3, 4, 1>); + return info; + } + case angle::FormatID::R8G8B8A8_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_SINT, + &CopyNativeVertexData<GLbyte, 4, 4, 0>); + return info; + } + + // GL_BYTE -- normalized + case angle::FormatID::R8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SNORM, + &CopyNativeVertexData<GLbyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SNORM, + &CopyNativeVertexData<GLbyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SNORM, + &CopyNativeVertexData<GLbyte, 3, 4, INT8_MAX>); + return info; + } + case angle::FormatID::R8G8B8A8_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SNORM, + &CopyNativeVertexData<GLbyte, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_BYTE -- un-normalized + case angle::FormatID::R8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_UINT, + &CopyNativeVertexData<GLubyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_UINT, + &CopyNativeVertexData<GLubyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 3, 4, 1>); + return info; + } + case angle::FormatID::R8G8B8A8_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_BYTE -- normalized + case angle::FormatID::R8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UNORM, + &CopyNativeVertexData<GLubyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UNORM, + &CopyNativeVertexData<GLubyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM, + &CopyNativeVertexData<GLubyte, 3, 4, UINT8_MAX>); + return info; + } + case angle::FormatID::R8G8B8A8_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UNORM, + &CopyNativeVertexData<GLubyte, 4, 4, 0>); + return info; + } + + // GL_SHORT -- un-normalized + case angle::FormatID::R16_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_SINT, + &CopyNativeVertexData<GLshort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_SINT, + &CopyNativeVertexData<GLshort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT, + &CopyNativeVertexData<GLshort, 3, 4, 1>); + return info; + } + case angle::FormatID::R16G16B16A16_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_SINT, + &CopyNativeVertexData<GLshort, 4, 4, 0>); + return info; + } + + // GL_SHORT -- normalized + case angle::FormatID::R16_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SNORM, + &CopyNativeVertexData<GLshort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SNORM, + &CopyNativeVertexData<GLshort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM, + &CopyNativeVertexData<GLshort, 3, 4, INT16_MAX>); + return info; + } + case angle::FormatID::R16G16B16A16_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SNORM, + &CopyNativeVertexData<GLshort, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_SHORT -- un-normalized + case angle::FormatID::R16_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_UINT, + &CopyNativeVertexData<GLushort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_UINT, + &CopyNativeVertexData<GLushort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_UINT, + &CopyNativeVertexData<GLushort, 3, 4, 1>); + return info; + } + case angle::FormatID::R16G16B16A16_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_UINT, + &CopyNativeVertexData<GLushort, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_SHORT -- normalized + case angle::FormatID::R16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UNORM, + &CopyNativeVertexData<GLushort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UNORM, + &CopyNativeVertexData<GLushort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UNORM, + &CopyNativeVertexData<GLushort, 3, 4, UINT16_MAX>); + return info; + } + case angle::FormatID::R16G16B16A16_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UNORM, + &CopyNativeVertexData<GLushort, 4, 4, 0>); + return info; + } + + // GL_INT -- un-normalized + case angle::FormatID::R32_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_SINT, + &CopyNativeVertexData<GLint, 1, 1, 0>); + return info; + } + case angle::FormatID::R32G32_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_SINT, + &CopyNativeVertexData<GLint, 2, 2, 0>); + return info; + } + case angle::FormatID::R32G32B32_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_SINT, + &CopyNativeVertexData<GLint, 3, 3, 0>); + return info; + } + case angle::FormatID::R32G32B32A32_SSCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_SINT, + &CopyNativeVertexData<GLint, 4, 4, 0>); + return info; + } + + // GL_INT -- normalized + case angle::FormatID::R32_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, + &CopyToFloatVertexData<GLint, 1, 1, true, false>); + return info; + } + case angle::FormatID::R32G32_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLint, 2, 2, true, false>); + return info; + } + case angle::FormatID::R32G32B32_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, + &CopyToFloatVertexData<GLint, 3, 3, true, false>); + return info; + } + case angle::FormatID::R32G32B32A32_SNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyToFloatVertexData<GLint, 4, 4, true, false>); + return info; + } + + // GL_UNSIGNED_INT -- un-normalized + case angle::FormatID::R32_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_UINT, + &CopyNativeVertexData<GLuint, 1, 1, 0>); + return info; + } + case angle::FormatID::R32G32_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_UINT, + &CopyNativeVertexData<GLuint, 2, 2, 0>); + return info; + } + case angle::FormatID::R32G32B32_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_UINT, + &CopyNativeVertexData<GLuint, 3, 3, 0>); + return info; + } + case angle::FormatID::R32G32B32A32_USCALED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_UINT, + &CopyNativeVertexData<GLuint, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_INT -- normalized + case angle::FormatID::R32_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, + &CopyToFloatVertexData<GLuint, 1, 1, true, false>); + return info; + } + case angle::FormatID::R32G32_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &CopyToFloatVertexData<GLuint, 2, 2, true, false>); + return info; + } + case angle::FormatID::R32G32B32_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, + &CopyToFloatVertexData<GLuint, 3, 3, true, false>); + return info; + } + case angle::FormatID::R32G32B32A32_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyToFloatVertexData<GLuint, 4, 4, true, false>); + return info; + } + + // GL_FIXED + case angle::FormatID::R32_FIXED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, + &Copy32FixedTo32FVertexData<1, 1>); + return info; + } + case angle::FormatID::R32G32_FIXED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, + &Copy32FixedTo32FVertexData<2, 2>); + return info; + } + case angle::FormatID::R32G32B32_FIXED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, + &Copy32FixedTo32FVertexData<3, 3>); + return info; + } + case angle::FormatID::R32G32B32A32_FIXED: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &Copy32FixedTo32FVertexData<4, 4>); + return info; + } + + // GL_HALF_FLOAT + case angle::FormatID::R16_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_FLOAT, + &CopyNativeVertexData<GLhalf, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_FLOAT, + &CopyNativeVertexData<GLhalf, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_FLOAT, + &CopyNativeVertexData<GLhalf, 3, 4, gl::Float16One>); + return info; + } + case angle::FormatID::R16G16B16A16_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_FLOAT, + &CopyNativeVertexData<GLhalf, 4, 4, 0>); + return info; + } + + // GL_FLOAT + case angle::FormatID::R32_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT, + &CopyNativeVertexData<GLfloat, 1, 1, 0>); + return info; + } + case angle::FormatID::R32G32_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT, + &CopyNativeVertexData<GLfloat, 2, 2, 0>); + return info; + } + case angle::FormatID::R32G32B32_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_FLOAT, + &CopyNativeVertexData<GLfloat, 3, 3, 0>); + return info; + } + case angle::FormatID::R32G32B32A32_FLOAT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyNativeVertexData<GLfloat, 4, 4, 0>); + return info; + } + + // GL_INT_2_10_10_10_REV + case angle::FormatID::R10G10B10A2_SSCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyXYZ10W2ToXYZWFloatVertexData<true, false, true, false>); + return info; + } + case angle::FormatID::R10G10B10A2_SNORM: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyXYZ10W2ToXYZWFloatVertexData<true, true, true, false>); + return info; + } + + // GL_UNSIGNED_INT_2_10_10_10_REV + case angle::FormatID::R10G10B10A2_USCALED: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, + &CopyXYZ10W2ToXYZWFloatVertexData<false, false, true, false>); + return info; + } + case angle::FormatID::R10G10B10A2_UNORM: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UNORM, + &CopyNativeVertexData<GLuint, 1, 1, 0>); + return info; + } + + // + // Integer Formats + // + + // GL_BYTE + case angle::FormatID::R8_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SINT, + &CopyNativeVertexData<GLbyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SINT, + &CopyNativeVertexData<GLbyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SINT, + &CopyNativeVertexData<GLbyte, 3, 4, 1>); + return info; + } + case angle::FormatID::R8G8B8A8_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SINT, + &CopyNativeVertexData<GLbyte, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_BYTE + case angle::FormatID::R8_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UINT, + &CopyNativeVertexData<GLubyte, 1, 1, 0>); + return info; + } + case angle::FormatID::R8G8_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UINT, + &CopyNativeVertexData<GLubyte, 2, 2, 0>); + return info; + } + case angle::FormatID::R8G8B8_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 3, 4, 1>); + return info; + } + case angle::FormatID::R8G8B8A8_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UINT, + &CopyNativeVertexData<GLubyte, 4, 4, 0>); + return info; + } + + // GL_SHORT + case angle::FormatID::R16_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SINT, + &CopyNativeVertexData<GLshort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SINT, + &CopyNativeVertexData<GLshort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, + &CopyNativeVertexData<GLshort, 3, 4, 1>); + return info; + } + case angle::FormatID::R16G16B16A16_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SINT, + &CopyNativeVertexData<GLshort, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_SHORT + case angle::FormatID::R16_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UINT, + &CopyNativeVertexData<GLushort, 1, 1, 0>); + return info; + } + case angle::FormatID::R16G16_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UINT, + &CopyNativeVertexData<GLushort, 2, 2, 0>); + return info; + } + case angle::FormatID::R16G16B16_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UINT, + &CopyNativeVertexData<GLushort, 3, 4, 1>); + return info; + } + case angle::FormatID::R16G16B16A16_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UINT, + &CopyNativeVertexData<GLushort, 4, 4, 0>); + return info; + } + + // GL_INT + case angle::FormatID::R32_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, + &CopyNativeVertexData<GLint, 1, 1, 0>); + return info; + } + case angle::FormatID::R32G32_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, + &CopyNativeVertexData<GLint, 2, 2, 0>); + return info; + } + case angle::FormatID::R32G32B32_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, + &CopyNativeVertexData<GLint, 3, 3, 0>); + return info; + } + case angle::FormatID::R32G32B32A32_SINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, + &CopyNativeVertexData<GLint, 4, 4, 0>); + return info; + } + + // GL_UNSIGNED_INT + case angle::FormatID::R32_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, + &CopyNativeVertexData<GLuint, 1, 1, 0>); + return info; + } + case angle::FormatID::R32G32_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, + &CopyNativeVertexData<GLuint, 2, 2, 0>); + return info; + } + case angle::FormatID::R32G32B32_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, + &CopyNativeVertexData<GLuint, 3, 3, 0>); + return info; + } + case angle::FormatID::R32G32B32A32_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, + &CopyNativeVertexData<GLuint, 4, 4, 0>); + return info; + } + + // GL_INT_2_10_10_10_REV + case angle::FormatID::R10G10B10A2_SINT: + { + static constexpr VertexFormat info( + VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, + &CopyXYZ10W2ToXYZWFloatVertexData<true, true, false, false>); + return info; + } + + // GL_UNSIGNED_INT_2_10_10_10_REV + case angle::FormatID::R10G10B10A2_UINT: + { + static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UINT, + &CopyNativeVertexData<GLuint, 1, 1, 0>); + return info; + } + + default: + { + static constexpr VertexFormat info; + return info; + } + } +} + +} // namespace d3d11 + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.h new file mode 100644 index 0000000000..e4c3994280 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/formatutils11.h @@ -0,0 +1,64 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// formatutils11.h: Queries for GL image formats and their translations to D3D11 +// formats. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_FORMATUTILS11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_FORMATUTILS11_H_ + +#include <map> + +#include "common/platform.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/copyvertex.h" +#include "libANGLE/renderer/d3d/formatutilsD3D.h" +#include "libANGLE/renderer/dxgi_format_map.h" +#include "libANGLE/renderer/renderer_utils.h" + +namespace rx +{ +struct Renderer11DeviceCaps; + +namespace d3d11 +{ + +// A texture might be stored as DXGI_FORMAT_R16_TYPELESS but store integer components, +// which are accessed through an DXGI_FORMAT_R16_SINT view. It's easy to write code which queries +// information about the wrong format. Therefore, use of this should be avoided where possible. + +bool SupportsMipGen(DXGI_FORMAT dxgiFormat, D3D_FEATURE_LEVEL featureLevel); + +struct DXGIFormatSize +{ + DXGIFormatSize(GLuint pixelBits, GLuint blockWidth, GLuint blockHeight); + + GLuint pixelBytes; + GLuint blockWidth; + GLuint blockHeight; +}; +const DXGIFormatSize &GetDXGIFormatSizeInfo(DXGI_FORMAT format); + +struct VertexFormat : private angle::NonCopyable +{ + constexpr VertexFormat(); + constexpr VertexFormat(VertexConversionType conversionType, + DXGI_FORMAT nativeFormat, + VertexCopyFunction copyFunction); + + VertexConversionType conversionType; + DXGI_FORMAT nativeFormat; + VertexCopyFunction copyFunction; +}; + +const VertexFormat &GetVertexFormatInfo(angle::FormatID vertexFormatID, + D3D_FEATURE_LEVEL featureLevel); +} // namespace d3d11 + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_FORMATUTILS11_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp new file mode 100644 index 0000000000..8cd97ee43d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp @@ -0,0 +1,2751 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// renderer11_utils.cpp: Conversion functions and other utility routines +// specific to the D3D11 renderer. + +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include <versionhelpers.h> +#include <algorithm> + +#include "common/debug.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/Program.h" +#include "libANGLE/State.h" +#include "libANGLE/VertexArray.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "libANGLE/renderer/driver_utils.h" +#include "libANGLE/renderer/dxgi_support_table.h" +#include "platform/FeaturesD3D_autogen.h" +#include "platform/PlatformMethods.h" + +namespace rx +{ + +namespace d3d11_gl +{ +namespace +{ +// TODO(xinghua.cao@intel.com): Get a more accurate limit. +static D3D_FEATURE_LEVEL kMinimumFeatureLevelForES31 = D3D_FEATURE_LEVEL_11_0; + +// Helper functor for querying DXGI support. Saves passing the parameters repeatedly. +class DXGISupportHelper : angle::NonCopyable +{ + public: + DXGISupportHelper(ID3D11Device *device, D3D_FEATURE_LEVEL featureLevel) + : mDevice(device), mFeatureLevel(featureLevel) + {} + + bool query(DXGI_FORMAT dxgiFormat, UINT supportMask) + { + if (dxgiFormat == DXGI_FORMAT_UNKNOWN) + return false; + + auto dxgiSupport = d3d11::GetDXGISupport(dxgiFormat, mFeatureLevel); + + UINT supportedBits = dxgiSupport.alwaysSupportedFlags; + + if ((dxgiSupport.optionallySupportedFlags & supportMask) != 0) + { + UINT formatSupport; + if (SUCCEEDED(mDevice->CheckFormatSupport(dxgiFormat, &formatSupport))) + { + supportedBits |= (formatSupport & supportMask); + } + else + { + // TODO(jmadill): find out why we fail this call sometimes in FL9_3 + // ERR() << "Error checking format support for format 0x" << std::hex << dxgiFormat; + } + } + + return ((supportedBits & supportMask) == supportMask); + } + + private: + ID3D11Device *mDevice; + D3D_FEATURE_LEVEL mFeatureLevel; +}; + +gl::TextureCaps GenerateTextureFormatCaps(gl::Version maxClientVersion, + GLenum internalFormat, + ID3D11Device *device, + const Renderer11DeviceCaps &renderer11DeviceCaps) +{ + gl::TextureCaps textureCaps; + + DXGISupportHelper support(device, renderer11DeviceCaps.featureLevel); + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); + + const gl::InternalFormat &internalFormatInfo = gl::GetSizedInternalFormatInfo(internalFormat); + + UINT texSupportMask = D3D11_FORMAT_SUPPORT_TEXTURE2D; + if (internalFormatInfo.depthBits == 0 && internalFormatInfo.stencilBits == 0) + { + texSupportMask |= D3D11_FORMAT_SUPPORT_TEXTURECUBE; + if (maxClientVersion.major > 2) + { + texSupportMask |= D3D11_FORMAT_SUPPORT_TEXTURE3D; + } + } + + textureCaps.texturable = support.query(formatInfo.texFormat, texSupportMask); + textureCaps.filterable = + support.query(formatInfo.srvFormat, D3D11_FORMAT_SUPPORT_SHADER_SAMPLE); + textureCaps.textureAttachment = + (support.query(formatInfo.rtvFormat, D3D11_FORMAT_SUPPORT_RENDER_TARGET)) || + (support.query(formatInfo.dsvFormat, D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)); + textureCaps.renderbuffer = textureCaps.textureAttachment; + textureCaps.blendable = textureCaps.renderbuffer; + + DXGI_FORMAT renderFormat = DXGI_FORMAT_UNKNOWN; + if (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) + { + renderFormat = formatInfo.dsvFormat; + } + else if (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) + { + renderFormat = formatInfo.rtvFormat; + } + if (renderFormat != DXGI_FORMAT_UNKNOWN && + support.query(renderFormat, D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET)) + { + // Assume 1x + textureCaps.sampleCounts.insert(1); + + for (unsigned int sampleCount = 2; sampleCount <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; + sampleCount *= 2) + { + UINT qualityCount = 0; + if (SUCCEEDED(device->CheckMultisampleQualityLevels(renderFormat, sampleCount, + &qualityCount))) + { + // Assume we always support lower sample counts + if (qualityCount == 0) + { + break; + } + textureCaps.sampleCounts.insert(sampleCount); + } + } + } + + return textureCaps; +} + +bool GetNPOTTextureSupport(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +float GetMaximumAnisotropy(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_MAX_MAXANISOTROPY; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_MAX_MAXANISOTROPY; + + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + return 16; + + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_DEFAULT_MAX_ANISOTROPY; + + default: + UNREACHABLE(); + return 0; + } +} + +bool GetOcclusionQuerySupport(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx + // ID3D11Device::CreateQuery + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + return true; + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetEventQuerySupport(D3D_FEATURE_LEVEL featureLevel) +{ + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx + // ID3D11Device::CreateQuery + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return true; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetInstancingSupport(D3D_FEATURE_LEVEL featureLevel) +{ + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx + // ID3D11Device::CreateInputLayout + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + // Feature Level 9_3 supports instancing, but slot 0 in the input layout must not be + // instanced. + // D3D9 has a similar restriction, where stream 0 must not be instanced. + // This restriction can be worked around by remapping any non-instanced slot to slot + // 0. + // This works because HLSL uses shader semantics to match the vertex inputs to the + // elements in the input layout, rather than the slots. + // Note that we only support instancing via ANGLE_instanced_array on 9_3, since 9_3 + // doesn't support OpenGL ES 3.0 + case D3D_FEATURE_LEVEL_9_3: + return true; + + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetFramebufferMultisampleSupport(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetFramebufferBlitSupport(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetDerivativeInstructionSupport(D3D_FEATURE_LEVEL featureLevel) +{ + // http://msdn.microsoft.com/en-us/library/windows/desktop/bb509588.aspx states that + // shader model + // ps_2_x is required for the ddx (and other derivative functions). + + // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx states that + // feature level + // 9.3 supports shader model ps_2_x. + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_9_3: + return true; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +bool GetShaderTextureLODSupport(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return true; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return false; + + default: + UNREACHABLE(); + return false; + } +} + +int GetMaximumSimultaneousRenderTargets(D3D_FEATURE_LEVEL featureLevel) +{ + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx + // ID3D11Device::CreateInputLayout + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; + + case D3D_FEATURE_LEVEL_9_3: + return D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximum2DTextureSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION; + + case D3D_FEATURE_LEVEL_9_3: + return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumCubeMapTextureSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_TEXTURECUBE_DIMENSION; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_TEXTURECUBE_DIMENSION; + + case D3D_FEATURE_LEVEL_9_3: + return D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximum2DTextureArraySize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximum3DTextureSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumViewportSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_VIEWPORT_BOUNDS_MAX; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_VIEWPORT_BOUNDS_MAX; + + // No constants for D3D11 Feature Level 9 viewport size limits, use the maximum + // texture sizes + case D3D_FEATURE_LEVEL_9_3: + return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumDrawIndexedIndexCount(D3D_FEATURE_LEVEL featureLevel) +{ + // D3D11 allows up to 2^32 elements, but we report max signed int for convenience since + // that's what's + // returned from glGetInteger + static_assert(D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32, + "Unexpected D3D11 constant value."); + static_assert(D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32, + "Unexpected D3D11 constant value."); + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return std::numeric_limits<GLint>::max(); + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + return D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT; + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumDrawVertexCount(D3D_FEATURE_LEVEL featureLevel) +{ + // D3D11 allows up to 2^32 elements, but we report max signed int for convenience since + // that's what's + // returned from glGetInteger + static_assert(D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32, "Unexpected D3D11 constant value."); + static_assert(D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32, "Unexpected D3D11 constant value."); + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return std::numeric_limits<GLint>::max(); + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + return D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT; + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumVertexInputSlots(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_STANDARD_VERTEX_ELEMENT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + return D3D10_1_STANDARD_VERTEX_ELEMENT_COUNT; + case D3D_FEATURE_LEVEL_10_0: + return D3D10_STANDARD_VERTEX_ELEMENT_COUNT; + + // From http://http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx + // "Max Input Slots" + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 16; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx + // ID3D11DeviceContext::VSSetConstantBuffers + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 255 - d3d11_gl::GetReservedVertexUniformVectors(featureLevel); + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumVertexUniformBlocks(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT; + + // Uniform blocks not supported on D3D11 Feature Level 9 + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetReservedVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) +{ + // According to The OpenGL ES Shading Language specifications + // (Language Version 1.00 section 10.16, Language Version 3.10 section 12.21) + // built-in special variables (e.g. gl_FragCoord, or gl_PointCoord) + // which are statically used in the shader should be included in the variable packing + // algorithm. + // Therefore, we should not reserve output vectors for them. + + switch (featureLevel) + { + // We must reserve one output vector for dx_Position. + // We also reserve one for gl_Position, which we unconditionally output on Feature + // Levels 10_0+, + // even if it's unused in the shader (e.g. for transform feedback). TODO: This could + // be improved. + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 2; + + // Just reserve dx_Position on Feature Level 9, since we don't ever need to output + // gl_Position. + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 1; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) +{ + static_assert(gl::IMPLEMENTATION_MAX_VARYING_VECTORS == D3D11_VS_OUTPUT_REGISTER_COUNT, + "Unexpected D3D11 constant value."); + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(featureLevel); + + case D3D_FEATURE_LEVEL_10_1: + return D3D10_1_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(featureLevel); + case D3D_FEATURE_LEVEL_10_0: + return D3D10_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(featureLevel); + + // Use Shader Model 2.X limits + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 8 - GetReservedVertexOutputVectors(featureLevel); + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumVertexTextureUnits(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; + + // Vertex textures not supported on D3D11 Feature Level 9 according to + // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx + // ID3D11DeviceContext::VSSetSamplers and ID3D11DeviceContext::VSSetShaderResources + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumPixelUniformVectors(D3D_FEATURE_LEVEL featureLevel) +{ + // TODO(geofflang): Remove hard-coded limit once the gl-uniform-arrays test can pass + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return 1024; // D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 1024; // D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + + // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx + // ID3D11DeviceContext::PSSetConstantBuffers + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 32 - d3d11_gl::GetReservedFragmentUniformVectors(featureLevel); + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumPixelUniformBlocks(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT; + + // Uniform blocks not supported on D3D11 Feature Level 9 + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumPixelInputVectors(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_PS_INPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(featureLevel); + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_PS_INPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(featureLevel); + + // Use Shader Model 2.X limits + case D3D_FEATURE_LEVEL_9_3: + return 8 - GetReservedVertexOutputVectors(featureLevel); + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 8 - GetReservedVertexOutputVectors(featureLevel); + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumPixelTextureUnits(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; + + // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx + // ID3D11DeviceContext::PSSetShaderResources + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 16; + + default: + UNREACHABLE(); + return 0; + } +} + +std::array<GLint, 3> GetMaxComputeWorkGroupCount(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return {{D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION, + D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION, + D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION}}; + default: + return {{0, 0, 0}}; + } +} + +std::array<GLint, 3> GetMaxComputeWorkGroupSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return {{D3D11_CS_THREAD_GROUP_MAX_X, D3D11_CS_THREAD_GROUP_MAX_Y, + D3D11_CS_THREAD_GROUP_MAX_Z}}; + default: + return {{0, 0, 0}}; + } +} + +int GetMaxComputeWorkGroupInvocations(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP; + default: + return 0; + } +} + +int GetMaxComputeSharedMemorySize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + // In D3D11 the maximum total size of all variables with the groupshared storage class is + // 32kb. + // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-variable-syntax + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return 32768; + default: + return 0; + } +} + +int GetMaximumComputeUniformVectors(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + default: + return 0; + } +} + +int GetMaximumComputeUniformBlocks(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - + d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT; + default: + return 0; + } +} + +int GetMaximumComputeTextureUnits(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; + default: + return 0; + } +} + +void SetUAVRelatedResourceLimits(D3D_FEATURE_LEVEL featureLevel, gl::Caps *caps) +{ + ASSERT(caps); + + GLuint reservedUAVsForAtomicCounterBuffers = 0u; + + // For pixel shaders, the render targets and unordered access views share the same resource + // slots when being written out. + // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476465(v=vs.85).aspx + GLuint maxNumRTVsAndUAVs = 0u; + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + // Currently we allocate 4 UAV slots for atomic counter buffers on feature level 11_1. + reservedUAVsForAtomicCounterBuffers = 4u; + maxNumRTVsAndUAVs = D3D11_1_UAV_SLOT_COUNT; + break; + case D3D_FEATURE_LEVEL_11_0: + // Currently we allocate 1 UAV slot for atomic counter buffers on feature level 11_0. + reservedUAVsForAtomicCounterBuffers = 1u; + maxNumRTVsAndUAVs = D3D11_PS_CS_UAV_REGISTER_COUNT; + break; + default: + return; + } + + // Set limits on atomic counter buffers in fragment shaders and compute shaders. + caps->maxCombinedAtomicCounterBuffers = reservedUAVsForAtomicCounterBuffers; + caps->maxShaderAtomicCounterBuffers[gl::ShaderType::Compute] = + reservedUAVsForAtomicCounterBuffers; + caps->maxShaderAtomicCounterBuffers[gl::ShaderType::Fragment] = + reservedUAVsForAtomicCounterBuffers; + caps->maxAtomicCounterBufferBindings = reservedUAVsForAtomicCounterBuffers; + + // Setting MAX_COMPUTE_ATOMIC_COUNTERS to a conservative number of 1024 * the number of UAV + // reserved for atomic counters. It could theoretically be set to max buffer size / 4 but that + // number could cause problems. + caps->maxCombinedAtomicCounters = reservedUAVsForAtomicCounterBuffers * 1024; + caps->maxShaderAtomicCounters[gl::ShaderType::Compute] = caps->maxCombinedAtomicCounters; + + // See + // https://docs.microsoft.com/en-us/windows/desktop/direct3d11/overviews-direct3d-11-resources-limits + // Resource size (in MB) for any of the preceding resources is min(max(128,0.25f * (amount of + // dedicated VRAM)), 2048) MB. So we set it to 128MB to keep same with GL backend. + caps->maxShaderStorageBlockSize = + D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM * 1024 * 1024; + + // Allocate the remaining slots for images and shader storage blocks. + // The maximum number of fragment shader outputs depends on the current context version, so we + // will not set it here. See comments in Context11::initialize(). + caps->maxCombinedShaderOutputResources = + maxNumRTVsAndUAVs - reservedUAVsForAtomicCounterBuffers; + + // Set limits on images and shader storage blocks in fragment shaders and compute shaders. + caps->maxCombinedShaderStorageBlocks = caps->maxCombinedShaderOutputResources; + caps->maxShaderStorageBlocks[gl::ShaderType::Compute] = caps->maxCombinedShaderOutputResources; + caps->maxShaderStorageBlocks[gl::ShaderType::Fragment] = caps->maxCombinedShaderOutputResources; + caps->maxShaderStorageBufferBindings = caps->maxCombinedShaderOutputResources; + + caps->maxImageUnits = caps->maxCombinedShaderOutputResources; + caps->maxCombinedImageUniforms = caps->maxCombinedShaderOutputResources; + caps->maxShaderImageUniforms[gl::ShaderType::Compute] = caps->maxCombinedShaderOutputResources; + caps->maxShaderImageUniforms[gl::ShaderType::Fragment] = caps->maxCombinedShaderOutputResources; + + // On feature level 11_1, UAVs are also available in vertex shaders and geometry shaders. + if (featureLevel == D3D_FEATURE_LEVEL_11_1) + { + caps->maxShaderAtomicCounterBuffers[gl::ShaderType::Vertex] = + caps->maxCombinedAtomicCounterBuffers; + caps->maxShaderAtomicCounterBuffers[gl::ShaderType::Geometry] = + caps->maxCombinedAtomicCounterBuffers; + + caps->maxShaderImageUniforms[gl::ShaderType::Vertex] = + caps->maxCombinedShaderOutputResources; + caps->maxShaderStorageBlocks[gl::ShaderType::Vertex] = + caps->maxCombinedShaderOutputResources; + caps->maxShaderImageUniforms[gl::ShaderType::Geometry] = + caps->maxCombinedShaderOutputResources; + caps->maxShaderStorageBlocks[gl::ShaderType::Geometry] = + caps->maxCombinedShaderOutputResources; + } +} + +int GetMinimumTexelOffset(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE; + + // Sampling functions with offsets are not available below shader model 4.0. + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumTexelOffset(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE; + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE; + + // Sampling functions with offsets are not available below shader model 4.0. + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMinimumTextureGatherOffset(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/gather4-po--sm5---asm- + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return -32; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumTextureGatherOffset(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/gather4-po--sm5---asm- + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return 31; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +size_t GetMaximumConstantBufferSize(D3D_FEATURE_LEVEL featureLevel) +{ + // Returns a size_t despite the limit being a GLuint64 because size_t is the maximum + // size of + // any buffer that could be allocated. + + const size_t bytesPerComponent = 4 * sizeof(float); + + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent; + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent; + + // Limits from http://msdn.microsoft.com/en-us/library/windows/desktop/ff476501.aspx + // remarks section + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 4096 * bytesPerComponent; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumStreamOutputBuffers(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_SO_BUFFER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_10_1: + return D3D10_1_SO_BUFFER_SLOT_COUNT; + case D3D_FEATURE_LEVEL_10_0: + return D3D10_SO_BUFFER_SLOT_COUNT; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumStreamOutputInterleavedComponents(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return GetMaximumVertexOutputVectors(featureLevel) * 4; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumStreamOutputSeparateComponents(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return GetMaximumStreamOutputInterleavedComponents(featureLevel) / + GetMaximumStreamOutputBuffers(featureLevel); + + // D3D 10 and 10.1 only allow one output per output slot if an output slot other + // than zero is used. + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 4; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + + default: + UNREACHABLE(); + return 0; + } +} + +int GetMaximumRenderToBufferWindowSize(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH; + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH; + + // REQ_RENDER_TO_BUFFER_WINDOW_WIDTH not supported on D3D11 Feature Level 9, + // use the maximum texture sizes + case D3D_FEATURE_LEVEL_9_3: + return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; + + default: + UNREACHABLE(); + return 0; + } +} + +IntelDriverVersion GetIntelDriverVersion(const Optional<LARGE_INTEGER> driverVersion) +{ + if (!driverVersion.valid()) + return IntelDriverVersion(0); + + DWORD lowPart = driverVersion.value().LowPart; + return IntelDriverVersion(HIWORD(lowPart) * 10000 + LOWORD(lowPart)); +} + +} // anonymous namespace + +unsigned int GetReservedVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 0; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 3; // dx_ViewAdjust, dx_ViewCoords and dx_ViewScale + + default: + UNREACHABLE(); + return 0; + } +} + +unsigned int GetReservedFragmentUniformVectors(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 0; + + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 4; // dx_ViewCoords, dx_DepthFront, dx_DepthRange, dx_FragCoordOffset + + default: + UNREACHABLE(); + return 0; + } +} + +gl::Version GetMaximumClientVersion(const Renderer11DeviceCaps &caps) +{ + switch (caps.featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return gl::Version(3, 1); + case D3D_FEATURE_LEVEL_10_1: + return gl::Version(3, 0); + + case D3D_FEATURE_LEVEL_10_0: + if (caps.allowES3OnFL10_0) + { + return gl::Version(3, 0); + } + else + { + return gl::Version(2, 0); + } + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return gl::Version(2, 0); + + default: + UNREACHABLE(); + return gl::Version(0, 0); + } +} + +D3D_FEATURE_LEVEL GetMinimumFeatureLevelForES31() +{ + return kMinimumFeatureLevelForES31; +} + +unsigned int GetMaxViewportAndScissorRectanglesPerPipeline(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE; + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 1; + default: + UNREACHABLE(); + return 0; + } +} + +bool IsMultiviewSupported(D3D_FEATURE_LEVEL featureLevel) +{ + // The ANGLE_multiview extension can always be supported in D3D11 through geometry shaders. + switch (featureLevel) + { + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + return true; + default: + return false; + } +} + +int GetMaxSampleMaskWords(D3D_FEATURE_LEVEL featureLevel) +{ + switch (featureLevel) + { + // D3D10+ only allows 1 sample mask. + case D3D_FEATURE_LEVEL_11_1: + case D3D_FEATURE_LEVEL_11_0: + case D3D_FEATURE_LEVEL_10_1: + case D3D_FEATURE_LEVEL_10_0: + return 1; + case D3D_FEATURE_LEVEL_9_3: + case D3D_FEATURE_LEVEL_9_2: + case D3D_FEATURE_LEVEL_9_1: + return 0; + default: + UNREACHABLE(); + return 0; + } +} + +bool HasTextureBufferSupport(ID3D11Device *device, const Renderer11DeviceCaps &renderer11DeviceCaps) +{ + if (renderer11DeviceCaps.featureLevel < D3D_FEATURE_LEVEL_11_0) + return false; + + if (!renderer11DeviceCaps.supportsTypedUAVLoadAdditionalFormats) + return false; + + // https://docs.microsoft.com/en-us/windows/win32/direct3d12/typed-unordered-access-view-loads + // we don't need to check the typed store. from the spec, + // https://microsoft.github.io/DirectX-Specs/d3d/archive/D3D11_3_FunctionalSpec.htm#FormatList + // all the following format support typed stored. + // According to spec, + // https://www.khronos.org/registry/OpenGL-Refpages/es3/html/glBindImageTexture.xhtml the + // required image unit format are GL_RGBA32F, GL_RGBA32UI, GL_RGBA32I, GL_RGBA16F, GL_RGBA16UI, + // GL_RGBA16I, GL_RGBA8, GL_RGBAUI, GL_RGBA8I, GL_RGBA8_SNORM, GL_R32F, GL_R32UI, GL_R32I, + const std::array<DXGI_FORMAT, 2> &optionalFormats = { + DXGI_FORMAT_R32G32B32A32_FLOAT, // test for GL_RGBA32(UIF), GL_RGBA16(UIF), + // GL_RGBA8(UIUnorm) + DXGI_FORMAT_R8G8B8A8_SNORM, // test for GL_RGBA8_SNORM, + }; + + for (DXGI_FORMAT dxgiFormat : optionalFormats) + { + D3D11_FEATURE_DATA_FORMAT_SUPPORT FormatSupport = {dxgiFormat, 0}; + if (!SUCCEEDED(device->CheckFeatureSupport(D3D11_FEATURE_FORMAT_SUPPORT, &FormatSupport, + sizeof(FormatSupport)))) + { + WARN() << "Error checking typed load support for format 0x" << std::hex << dxgiFormat; + return false; + } + if ((FormatSupport.OutFormatSupport & D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD) == 0) + return false; + } + return true; +} + +void GenerateCaps(ID3D11Device *device, + ID3D11DeviceContext *deviceContext, + const Renderer11DeviceCaps &renderer11DeviceCaps, + const angle::FeaturesD3D &features, + const char *description, + gl::Caps *caps, + gl::TextureCapsMap *textureCapsMap, + gl::Extensions *extensions, + gl::Limitations *limitations) +{ + D3D_FEATURE_LEVEL featureLevel = renderer11DeviceCaps.featureLevel; + const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats(); + for (GLenum internalFormat : allFormats) + { + gl::TextureCaps textureCaps = + GenerateTextureFormatCaps(GetMaximumClientVersion(renderer11DeviceCaps), internalFormat, + device, renderer11DeviceCaps); + textureCapsMap->insert(internalFormat, textureCaps); + } + + // GL core feature limits + // Reserve MAX_UINT for D3D11's primitive restart. + caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max() - 1); + caps->max3DTextureSize = GetMaximum3DTextureSize(featureLevel); + caps->max2DTextureSize = GetMaximum2DTextureSize(featureLevel); + caps->maxCubeMapTextureSize = GetMaximumCubeMapTextureSize(featureLevel); + caps->maxArrayTextureLayers = GetMaximum2DTextureArraySize(featureLevel); + + // Unimplemented, set to minimum required + caps->maxLODBias = 2.0f; + + // No specific limits on render target size, maximum 2D texture size is equivalent + caps->maxRenderbufferSize = caps->max2DTextureSize; + + // Maximum draw buffers and color attachments are the same, max color attachments could + // eventually be increased to 16 + caps->maxDrawBuffers = GetMaximumSimultaneousRenderTargets(featureLevel); + caps->maxColorAttachments = GetMaximumSimultaneousRenderTargets(featureLevel); + + // D3D11 has the same limit for viewport width and height + caps->maxViewportWidth = GetMaximumViewportSize(featureLevel); + caps->maxViewportHeight = caps->maxViewportWidth; + + // Choose a reasonable maximum, enforced in the shader. + caps->minAliasedPointSize = 1.0f; + caps->maxAliasedPointSize = 1024.0f; + + // Wide lines not supported + caps->minAliasedLineWidth = 1.0f; + caps->maxAliasedLineWidth = 1.0f; + + // Primitive count limits + caps->maxElementsIndices = GetMaximumDrawIndexedIndexCount(featureLevel); + caps->maxElementsVertices = GetMaximumDrawVertexCount(featureLevel); + + // Program and shader binary formats (no supported shader binary formats) + caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE); + + caps->vertexHighpFloat.setIEEEFloat(); + caps->vertexMediumpFloat.setIEEEFloat(); + caps->vertexLowpFloat.setIEEEFloat(); + caps->fragmentHighpFloat.setIEEEFloat(); + caps->fragmentMediumpFloat.setIEEEFloat(); + caps->fragmentLowpFloat.setIEEEFloat(); + + // 32-bit integers are natively supported + caps->vertexHighpInt.setTwosComplementInt(32); + caps->vertexMediumpInt.setTwosComplementInt(32); + caps->vertexLowpInt.setTwosComplementInt(32); + caps->fragmentHighpInt.setTwosComplementInt(32); + caps->fragmentMediumpInt.setTwosComplementInt(32); + caps->fragmentLowpInt.setTwosComplementInt(32); + + // We do not wait for server fence objects internally, so report a max timeout of zero. + caps->maxServerWaitTimeout = 0; + + // Vertex shader limits + caps->maxVertexAttributes = GetMaximumVertexInputSlots(featureLevel); + caps->maxVertexUniformVectors = GetMaximumVertexUniformVectors(featureLevel); + if (features.skipVSConstantRegisterZero.enabled) + { + caps->maxVertexUniformVectors -= 1; + } + caps->maxShaderUniformComponents[gl::ShaderType::Vertex] = caps->maxVertexUniformVectors * 4; + caps->maxShaderUniformBlocks[gl::ShaderType::Vertex] = + GetMaximumVertexUniformBlocks(featureLevel); + caps->maxVertexOutputComponents = GetMaximumVertexOutputVectors(featureLevel) * 4; + caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] = + GetMaximumVertexTextureUnits(featureLevel); + + // Vertex Attribute Bindings are emulated on D3D11. + caps->maxVertexAttribBindings = caps->maxVertexAttributes; + // Experimental testing confirmed there is no explicit limit on maximum buffer offset in D3D11. + caps->maxVertexAttribRelativeOffset = std::numeric_limits<GLint>::max(); + // Experimental testing confirmed 2048 is the maximum stride that D3D11 can support on all + // platforms. + caps->maxVertexAttribStride = 2048; + + // Fragment shader limits + caps->maxFragmentUniformVectors = GetMaximumPixelUniformVectors(featureLevel); + caps->maxShaderUniformComponents[gl::ShaderType::Fragment] = + caps->maxFragmentUniformVectors * 4; + caps->maxShaderUniformBlocks[gl::ShaderType::Fragment] = + GetMaximumPixelUniformBlocks(featureLevel); + caps->maxFragmentInputComponents = GetMaximumPixelInputVectors(featureLevel) * 4; + caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment] = + GetMaximumPixelTextureUnits(featureLevel); + caps->minProgramTexelOffset = GetMinimumTexelOffset(featureLevel); + caps->maxProgramTexelOffset = GetMaximumTexelOffset(featureLevel); + + // Compute shader limits + caps->maxComputeWorkGroupCount = GetMaxComputeWorkGroupCount(featureLevel); + caps->maxComputeWorkGroupSize = GetMaxComputeWorkGroupSize(featureLevel); + caps->maxComputeWorkGroupInvocations = GetMaxComputeWorkGroupInvocations(featureLevel); + caps->maxComputeSharedMemorySize = GetMaxComputeSharedMemorySize(featureLevel); + caps->maxShaderUniformComponents[gl::ShaderType::Compute] = + GetMaximumComputeUniformVectors(featureLevel) * 4; + caps->maxShaderUniformBlocks[gl::ShaderType::Compute] = + GetMaximumComputeUniformBlocks(featureLevel); + caps->maxShaderTextureImageUnits[gl::ShaderType::Compute] = + GetMaximumComputeTextureUnits(featureLevel); + + SetUAVRelatedResourceLimits(featureLevel, caps); + + // Aggregate shader limits + caps->maxUniformBufferBindings = caps->maxShaderUniformBlocks[gl::ShaderType::Vertex] + + caps->maxShaderUniformBlocks[gl::ShaderType::Fragment]; + caps->maxUniformBlockSize = static_cast<GLuint64>(GetMaximumConstantBufferSize(featureLevel)); + + // TODO(oetuaho): Get a more accurate limit. For now using the minimum requirement for GLES 3.1. + caps->maxUniformLocations = 1024; + + // With DirectX 11.1, constant buffer offset and size must be a multiple of 16 constants of 16 + // bytes each. + // https://msdn.microsoft.com/en-us/library/windows/desktop/hh404649%28v=vs.85%29.aspx + // With DirectX 11.0, we emulate UBO offsets using copies of ranges of the UBO however + // we still keep the same alignment as 11.1 for consistency. + caps->uniformBufferOffsetAlignment = 256; + + caps->maxCombinedUniformBlocks = caps->maxShaderUniformBlocks[gl::ShaderType::Vertex] + + caps->maxShaderUniformBlocks[gl::ShaderType::Fragment]; + + // A shader storage block will be translated to a structure in HLSL. So We reference the HLSL + // structure packing rules + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb509632(v=vs.85).aspx. The + // resulting size of any structure will always be evenly divisible by sizeof(four-component + // vector). + caps->shaderStorageBufferOffsetAlignment = 16; + + for (gl::ShaderType shaderType : gl::AllShaderTypes()) + { + caps->maxCombinedShaderUniformComponents[shaderType] = + static_cast<GLint64>(caps->maxShaderUniformBlocks[shaderType]) * + static_cast<GLint64>(caps->maxUniformBlockSize / 4) + + static_cast<GLint64>(caps->maxShaderUniformComponents[shaderType]); + } + + caps->maxVaryingComponents = GetMaximumVertexOutputVectors(featureLevel) * 4; + caps->maxVaryingVectors = GetMaximumVertexOutputVectors(featureLevel); + caps->maxCombinedTextureImageUnits = caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] + + caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment]; + + // Transform feedback limits + caps->maxTransformFeedbackInterleavedComponents = + GetMaximumStreamOutputInterleavedComponents(featureLevel); + caps->maxTransformFeedbackSeparateAttributes = GetMaximumStreamOutputBuffers(featureLevel); + caps->maxTransformFeedbackSeparateComponents = + GetMaximumStreamOutputSeparateComponents(featureLevel); + + // Defer the computation of multisample limits to Context::updateCaps() where max*Samples values + // are determined according to available sample counts for each individual format. + caps->maxSamples = std::numeric_limits<GLint>::max(); + caps->maxColorTextureSamples = std::numeric_limits<GLint>::max(); + caps->maxDepthTextureSamples = std::numeric_limits<GLint>::max(); + caps->maxIntegerSamples = std::numeric_limits<GLint>::max(); + + // Sample mask words limits + caps->maxSampleMaskWords = GetMaxSampleMaskWords(featureLevel); + + // Framebuffer limits + caps->maxFramebufferSamples = std::numeric_limits<GLint>::max(); + caps->maxFramebufferWidth = GetMaximumRenderToBufferWindowSize(featureLevel); + caps->maxFramebufferHeight = caps->maxFramebufferWidth; + + // Texture gather offset limits + caps->minProgramTextureGatherOffset = GetMinimumTextureGatherOffset(featureLevel); + caps->maxProgramTextureGatherOffset = GetMaximumTextureGatherOffset(featureLevel); + + caps->maxTextureAnisotropy = GetMaximumAnisotropy(featureLevel); + caps->queryCounterBitsTimeElapsed = 64; + caps->queryCounterBitsTimestamp = 0; // Timestamps cannot be supported due to D3D11 limitations + caps->maxDualSourceDrawBuffers = 1; + + // GL extension support + extensions->setTextureExtensionSupport(*textureCapsMap); + + // Explicitly disable GL_OES_compressed_ETC1_RGB8_texture because it's emulated and never + // becomes core. WebGL doesn't want to expose it unless there is native support. + extensions->compressedETC1RGB8TextureOES = false; + extensions->compressedETC1RGB8SubTextureEXT = false; + + extensions->elementIndexUintOES = true; + extensions->getProgramBinaryOES = true; + extensions->rgb8Rgba8OES = true; + extensions->readFormatBgraEXT = true; + extensions->pixelBufferObjectNV = true; + extensions->mapbufferOES = true; + extensions->mapBufferRangeEXT = true; + extensions->textureNpotOES = GetNPOTTextureSupport(featureLevel); + extensions->drawBuffersEXT = GetMaximumSimultaneousRenderTargets(featureLevel) > 1; + extensions->drawBuffersIndexedEXT = + (renderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_1); + extensions->drawBuffersIndexedOES = extensions->drawBuffersIndexedEXT; + extensions->textureStorageEXT = true; + extensions->textureFilterAnisotropicEXT = true; + extensions->occlusionQueryBooleanEXT = GetOcclusionQuerySupport(featureLevel); + extensions->fenceNV = GetEventQuerySupport(featureLevel); + extensions->disjointTimerQueryEXT = true; + extensions->robustnessEXT = true; + // Direct3D guarantees to return zero for any resource that is accessed out of bounds. + // See https://msdn.microsoft.com/en-us/library/windows/desktop/ff476332(v=vs.85).aspx + // and https://msdn.microsoft.com/en-us/library/windows/desktop/ff476900(v=vs.85).aspx + extensions->robustBufferAccessBehaviorKHR = true; + extensions->blendMinmaxEXT = true; + // https://docs.microsoft.com/en-us/windows/desktop/direct3ddxgi/format-support-for-direct3d-11-0-feature-level-hardware + extensions->floatBlendEXT = true; + extensions->framebufferBlitANGLE = GetFramebufferBlitSupport(featureLevel); + extensions->framebufferBlitNV = extensions->framebufferBlitANGLE; + extensions->framebufferMultisampleANGLE = GetFramebufferMultisampleSupport(featureLevel); + extensions->instancedArraysANGLE = GetInstancingSupport(featureLevel); + extensions->instancedArraysEXT = GetInstancingSupport(featureLevel); + extensions->packReverseRowOrderANGLE = true; + extensions->standardDerivativesOES = GetDerivativeInstructionSupport(featureLevel); + extensions->shaderTextureLodEXT = GetShaderTextureLODSupport(featureLevel); + extensions->fragDepthEXT = true; + extensions->multiviewOVR = IsMultiviewSupported(featureLevel); + extensions->multiview2OVR = IsMultiviewSupported(featureLevel); + if (extensions->multiviewOVR || extensions->multiview2OVR) + { + caps->maxViews = std::min(static_cast<GLuint>(GetMaximum2DTextureArraySize(featureLevel)), + GetMaxViewportAndScissorRectanglesPerPipeline(featureLevel)); + } + extensions->textureUsageANGLE = true; // This could be false since it has no effect in D3D11 + extensions->discardFramebufferEXT = true; + extensions->translatedShaderSourceANGLE = true; + extensions->fboRenderMipmapOES = true; + extensions->debugMarkerEXT = true; + extensions->EGLImageOES = true; + extensions->EGLImageExternalOES = true; + extensions->EGLImageExternalWrapModesEXT = true; + extensions->EGLImageExternalEssl3OES = true; + extensions->EGLStreamConsumerExternalNV = true; + extensions->unpackSubimageEXT = true; + extensions->packSubimageNV = true; + extensions->lossyEtcDecodeANGLE = true; + extensions->syncQueryCHROMIUM = GetEventQuerySupport(featureLevel); + extensions->copyTextureCHROMIUM = true; + extensions->copyCompressedTextureCHROMIUM = true; + extensions->textureStorageMultisample2dArrayOES = true; + extensions->multiviewMultisampleANGLE = + ((extensions->multiviewOVR || extensions->multiview2OVR) && + extensions->textureStorageMultisample2dArrayOES); + extensions->copyTexture3dANGLE = true; + extensions->textureBorderClampOES = true; + extensions->multiDrawIndirectEXT = true; + extensions->textureMultisampleANGLE = true; + extensions->provokingVertexANGLE = true; + extensions->blendFuncExtendedEXT = true; + // http://anglebug.com/4926 + extensions->texture3DOES = false; + extensions->baseInstanceEXT = true; + extensions->baseVertexBaseInstanceANGLE = true; + extensions->baseVertexBaseInstanceShaderBuiltinANGLE = true; + extensions->drawElementsBaseVertexOES = true; + extensions->drawElementsBaseVertexEXT = true; + if (!strstr(description, "Adreno")) + { + extensions->multisampledRenderToTextureEXT = true; + } + extensions->videoTextureWEBGL = true; + + // D3D11 cannot support reading depth texture as a luminance texture. + // It treats it as a red-channel-only texture. + extensions->depthTextureOES = false; + + // readPixels on depth & stencil not working with D3D11 backend. + extensions->readDepthNV = false; + extensions->readStencilNV = false; + extensions->depthBufferFloat2NV = false; + + // GL_EXT_clip_control + extensions->clipControlEXT = (renderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_9_3); + + // GL_KHR_parallel_shader_compile + extensions->parallelShaderCompileKHR = true; + + // GL_EXT_texture_buffer + extensions->textureBufferEXT = HasTextureBufferSupport(device, renderer11DeviceCaps); + + // GL_OES_texture_buffer + extensions->textureBufferOES = extensions->textureBufferEXT; + + // ANGLE_shader_pixel_local_storage -- fragment shader UAVs appear in D3D 11.0. + extensions->shaderPixelLocalStorageANGLE = (featureLevel >= D3D_FEATURE_LEVEL_11_0); + extensions->shaderPixelLocalStorageCoherentANGLE = + renderer11DeviceCaps.supportsRasterizerOrderViews; + + // D3D11 Feature Level 10_0+ uses SV_IsFrontFace in HLSL to emulate gl_FrontFacing. + // D3D11 Feature Level 9_3 doesn't support SV_IsFrontFace, and has no equivalent, so can't + // support gl_FrontFacing. + limitations->noFrontFacingSupport = + (renderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3); + + // D3D11 Feature Level 9_3 doesn't support alpha-to-coverage + limitations->noSampleAlphaToCoverageSupport = + (renderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3); + + // D3D11 Feature Levels 9_3 and below do not support non-constant loop indexing and require + // additional + // pre-validation of the shader at compile time to produce a better error message. + limitations->shadersRequireIndexedLoopValidation = + (renderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3); + + // D3D11 has no concept of separate masks and refs for front and back faces in the depth stencil + // state. + limitations->noSeparateStencilRefsAndMasks = true; + + // D3D11 cannot support constant color and alpha blend funcs together + limitations->noSimultaneousConstantColorAndAlphaBlendFunc = true; + + // D3D11 does not support multiple transform feedback outputs writing to the same buffer. + limitations->noDoubleBoundTransformFeedbackBuffers = true; + + // D3D11 does not support vertex attribute aliasing + limitations->noVertexAttributeAliasing = true; + + // D3D11 does not support compressed textures where the base mip level is not a multiple of 4 + limitations->compressedBaseMipLevelMultipleOfFour = true; + + if (extensions->textureBufferAny()) + { + caps->maxTextureBufferSize = 1 << D3D11_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP; + // this maybe touble for RGB32 format. + caps->textureBufferOffsetAlignment = 16; + } + +#ifdef ANGLE_ENABLE_WINDOWS_UWP + // Setting a non-zero divisor on attribute zero doesn't work on certain Windows Phone 8-era + // devices. We should prevent developers from doing this on ALL Windows Store devices. This will + // maintain consistency across all Windows devices. We allow non-zero divisors on attribute zero + // if the Client Version >= 3, since devices affected by this issue don't support ES3+. + limitations->attributeZeroRequiresZeroDivisorInEXT = true; +#endif +} + +} // namespace d3d11_gl + +namespace gl_d3d11 +{ + +D3D11_BLEND ConvertBlendFunc(GLenum glBlend, bool isAlpha) +{ + D3D11_BLEND d3dBlend = D3D11_BLEND_ZERO; + + switch (glBlend) + { + case GL_ZERO: + d3dBlend = D3D11_BLEND_ZERO; + break; + case GL_ONE: + d3dBlend = D3D11_BLEND_ONE; + break; + case GL_SRC_COLOR: + d3dBlend = (isAlpha ? D3D11_BLEND_SRC_ALPHA : D3D11_BLEND_SRC_COLOR); + break; + case GL_ONE_MINUS_SRC_COLOR: + d3dBlend = (isAlpha ? D3D11_BLEND_INV_SRC_ALPHA : D3D11_BLEND_INV_SRC_COLOR); + break; + case GL_DST_COLOR: + d3dBlend = (isAlpha ? D3D11_BLEND_DEST_ALPHA : D3D11_BLEND_DEST_COLOR); + break; + case GL_ONE_MINUS_DST_COLOR: + d3dBlend = (isAlpha ? D3D11_BLEND_INV_DEST_ALPHA : D3D11_BLEND_INV_DEST_COLOR); + break; + case GL_SRC_ALPHA: + d3dBlend = D3D11_BLEND_SRC_ALPHA; + break; + case GL_ONE_MINUS_SRC_ALPHA: + d3dBlend = D3D11_BLEND_INV_SRC_ALPHA; + break; + case GL_DST_ALPHA: + d3dBlend = D3D11_BLEND_DEST_ALPHA; + break; + case GL_ONE_MINUS_DST_ALPHA: + d3dBlend = D3D11_BLEND_INV_DEST_ALPHA; + break; + case GL_CONSTANT_COLOR: + d3dBlend = D3D11_BLEND_BLEND_FACTOR; + break; + case GL_ONE_MINUS_CONSTANT_COLOR: + d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR; + break; + case GL_CONSTANT_ALPHA: + d3dBlend = D3D11_BLEND_BLEND_FACTOR; + break; + case GL_ONE_MINUS_CONSTANT_ALPHA: + d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR; + break; + case GL_SRC_ALPHA_SATURATE: + d3dBlend = D3D11_BLEND_SRC_ALPHA_SAT; + break; + case GL_SRC1_COLOR_EXT: + d3dBlend = (isAlpha ? D3D11_BLEND_SRC1_ALPHA : D3D11_BLEND_SRC1_COLOR); + break; + case GL_SRC1_ALPHA_EXT: + d3dBlend = D3D11_BLEND_SRC1_ALPHA; + break; + case GL_ONE_MINUS_SRC1_COLOR_EXT: + d3dBlend = (isAlpha ? D3D11_BLEND_INV_SRC1_ALPHA : D3D11_BLEND_INV_SRC1_COLOR); + break; + case GL_ONE_MINUS_SRC1_ALPHA_EXT: + d3dBlend = D3D11_BLEND_INV_SRC1_ALPHA; + break; + default: + UNREACHABLE(); + } + + return d3dBlend; +} + +D3D11_BLEND_OP ConvertBlendOp(GLenum glBlendOp) +{ + D3D11_BLEND_OP d3dBlendOp = D3D11_BLEND_OP_ADD; + + switch (glBlendOp) + { + case GL_FUNC_ADD: + d3dBlendOp = D3D11_BLEND_OP_ADD; + break; + case GL_FUNC_SUBTRACT: + d3dBlendOp = D3D11_BLEND_OP_SUBTRACT; + break; + case GL_FUNC_REVERSE_SUBTRACT: + d3dBlendOp = D3D11_BLEND_OP_REV_SUBTRACT; + break; + case GL_MIN: + d3dBlendOp = D3D11_BLEND_OP_MIN; + break; + case GL_MAX: + d3dBlendOp = D3D11_BLEND_OP_MAX; + break; + default: + UNREACHABLE(); + } + + return d3dBlendOp; +} + +UINT8 ConvertColorMask(bool red, bool green, bool blue, bool alpha) +{ + UINT8 mask = 0; + if (red) + { + mask |= D3D11_COLOR_WRITE_ENABLE_RED; + } + if (green) + { + mask |= D3D11_COLOR_WRITE_ENABLE_GREEN; + } + if (blue) + { + mask |= D3D11_COLOR_WRITE_ENABLE_BLUE; + } + if (alpha) + { + mask |= D3D11_COLOR_WRITE_ENABLE_ALPHA; + } + return mask; +} + +D3D11_CULL_MODE ConvertCullMode(bool cullEnabled, gl::CullFaceMode cullMode) +{ + D3D11_CULL_MODE cull = D3D11_CULL_NONE; + + if (cullEnabled) + { + switch (cullMode) + { + case gl::CullFaceMode::Front: + cull = D3D11_CULL_FRONT; + break; + case gl::CullFaceMode::Back: + cull = D3D11_CULL_BACK; + break; + case gl::CullFaceMode::FrontAndBack: + cull = D3D11_CULL_NONE; + break; + default: + UNREACHABLE(); + } + } + else + { + cull = D3D11_CULL_NONE; + } + + return cull; +} + +D3D11_COMPARISON_FUNC ConvertComparison(GLenum comparison) +{ + D3D11_COMPARISON_FUNC d3dComp = D3D11_COMPARISON_NEVER; + switch (comparison) + { + case GL_NEVER: + d3dComp = D3D11_COMPARISON_NEVER; + break; + case GL_ALWAYS: + d3dComp = D3D11_COMPARISON_ALWAYS; + break; + case GL_LESS: + d3dComp = D3D11_COMPARISON_LESS; + break; + case GL_LEQUAL: + d3dComp = D3D11_COMPARISON_LESS_EQUAL; + break; + case GL_EQUAL: + d3dComp = D3D11_COMPARISON_EQUAL; + break; + case GL_GREATER: + d3dComp = D3D11_COMPARISON_GREATER; + break; + case GL_GEQUAL: + d3dComp = D3D11_COMPARISON_GREATER_EQUAL; + break; + case GL_NOTEQUAL: + d3dComp = D3D11_COMPARISON_NOT_EQUAL; + break; + default: + UNREACHABLE(); + } + + return d3dComp; +} + +D3D11_DEPTH_WRITE_MASK ConvertDepthMask(bool depthWriteEnabled) +{ + return depthWriteEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; +} + +UINT8 ConvertStencilMask(GLuint stencilmask) +{ + return static_cast<UINT8>(stencilmask); +} + +D3D11_STENCIL_OP ConvertStencilOp(GLenum stencilOp) +{ + D3D11_STENCIL_OP d3dStencilOp = D3D11_STENCIL_OP_KEEP; + + switch (stencilOp) + { + case GL_ZERO: + d3dStencilOp = D3D11_STENCIL_OP_ZERO; + break; + case GL_KEEP: + d3dStencilOp = D3D11_STENCIL_OP_KEEP; + break; + case GL_REPLACE: + d3dStencilOp = D3D11_STENCIL_OP_REPLACE; + break; + case GL_INCR: + d3dStencilOp = D3D11_STENCIL_OP_INCR_SAT; + break; + case GL_DECR: + d3dStencilOp = D3D11_STENCIL_OP_DECR_SAT; + break; + case GL_INVERT: + d3dStencilOp = D3D11_STENCIL_OP_INVERT; + break; + case GL_INCR_WRAP: + d3dStencilOp = D3D11_STENCIL_OP_INCR; + break; + case GL_DECR_WRAP: + d3dStencilOp = D3D11_STENCIL_OP_DECR; + break; + default: + UNREACHABLE(); + } + + return d3dStencilOp; +} + +D3D11_FILTER ConvertFilter(GLenum minFilter, + GLenum magFilter, + float maxAnisotropy, + GLenum comparisonMode) +{ + bool comparison = comparisonMode != GL_NONE; + + if (maxAnisotropy > 1.0f) + { + return D3D11_ENCODE_ANISOTROPIC_FILTER(static_cast<D3D11_COMPARISON_FUNC>(comparison)); + } + else + { + D3D11_FILTER_TYPE dxMin = D3D11_FILTER_TYPE_POINT; + D3D11_FILTER_TYPE dxMip = D3D11_FILTER_TYPE_POINT; + switch (minFilter) + { + case GL_NEAREST: + dxMin = D3D11_FILTER_TYPE_POINT; + dxMip = D3D11_FILTER_TYPE_POINT; + break; + case GL_LINEAR: + dxMin = D3D11_FILTER_TYPE_LINEAR; + dxMip = D3D11_FILTER_TYPE_POINT; + break; + case GL_NEAREST_MIPMAP_NEAREST: + dxMin = D3D11_FILTER_TYPE_POINT; + dxMip = D3D11_FILTER_TYPE_POINT; + break; + case GL_LINEAR_MIPMAP_NEAREST: + dxMin = D3D11_FILTER_TYPE_LINEAR; + dxMip = D3D11_FILTER_TYPE_POINT; + break; + case GL_NEAREST_MIPMAP_LINEAR: + dxMin = D3D11_FILTER_TYPE_POINT; + dxMip = D3D11_FILTER_TYPE_LINEAR; + break; + case GL_LINEAR_MIPMAP_LINEAR: + dxMin = D3D11_FILTER_TYPE_LINEAR; + dxMip = D3D11_FILTER_TYPE_LINEAR; + break; + default: + UNREACHABLE(); + } + + D3D11_FILTER_TYPE dxMag = D3D11_FILTER_TYPE_POINT; + switch (magFilter) + { + case GL_NEAREST: + dxMag = D3D11_FILTER_TYPE_POINT; + break; + case GL_LINEAR: + dxMag = D3D11_FILTER_TYPE_LINEAR; + break; + default: + UNREACHABLE(); + } + + return D3D11_ENCODE_BASIC_FILTER(dxMin, dxMag, dxMip, + static_cast<D3D11_COMPARISON_FUNC>(comparison)); + } +} + +D3D11_TEXTURE_ADDRESS_MODE ConvertTextureWrap(GLenum wrap) +{ + switch (wrap) + { + case GL_REPEAT: + return D3D11_TEXTURE_ADDRESS_WRAP; + case GL_CLAMP_TO_EDGE: + return D3D11_TEXTURE_ADDRESS_CLAMP; + case GL_CLAMP_TO_BORDER: + return D3D11_TEXTURE_ADDRESS_BORDER; + case GL_MIRRORED_REPEAT: + return D3D11_TEXTURE_ADDRESS_MIRROR; + default: + UNREACHABLE(); + } + + return D3D11_TEXTURE_ADDRESS_WRAP; +} + +UINT ConvertMaxAnisotropy(float maxAnisotropy, D3D_FEATURE_LEVEL featureLevel) +{ + return static_cast<UINT>(std::min(maxAnisotropy, d3d11_gl::GetMaximumAnisotropy(featureLevel))); +} + +D3D11_QUERY ConvertQueryType(gl::QueryType type) +{ + switch (type) + { + case gl::QueryType::AnySamples: + case gl::QueryType::AnySamplesConservative: + return D3D11_QUERY_OCCLUSION; + case gl::QueryType::TransformFeedbackPrimitivesWritten: + return D3D11_QUERY_SO_STATISTICS; + case gl::QueryType::TimeElapsed: + // Two internal queries are also created for begin/end timestamps + return D3D11_QUERY_TIMESTAMP_DISJOINT; + case gl::QueryType::CommandsCompleted: + return D3D11_QUERY_EVENT; + default: + UNREACHABLE(); + return D3D11_QUERY_EVENT; + } +} + +// Get the D3D11 write mask covering all color channels of a given format +UINT8 GetColorMask(const gl::InternalFormat &format) +{ + return ConvertColorMask(format.redBits > 0, format.greenBits > 0, format.blueBits > 0, + format.alphaBits > 0); +} + +} // namespace gl_d3d11 + +namespace d3d11 +{ + +ANGLED3D11DeviceType GetDeviceType(ID3D11Device *device) +{ + // Note that this function returns an ANGLED3D11DeviceType rather than a D3D_DRIVER_TYPE value, + // since it is difficult to tell Software and Reference devices apart + + IDXGIDevice *dxgiDevice = nullptr; + IDXGIAdapter *dxgiAdapter = nullptr; + IDXGIAdapter2 *dxgiAdapter2 = nullptr; + + ANGLED3D11DeviceType retDeviceType = ANGLE_D3D11_DEVICE_TYPE_UNKNOWN; + + HRESULT hr = device->QueryInterface(__uuidof(IDXGIDevice), (void **)&dxgiDevice); + if (SUCCEEDED(hr)) + { + hr = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&dxgiAdapter); + if (SUCCEEDED(hr)) + { + std::wstring adapterString; + HRESULT adapter2hr = + dxgiAdapter->QueryInterface(__uuidof(dxgiAdapter2), (void **)&dxgiAdapter2); + if (SUCCEEDED(adapter2hr)) + { + // On D3D_FEATURE_LEVEL_9_*, IDXGIAdapter::GetDesc returns "Software Adapter" + // for the description string. Try to use IDXGIAdapter2::GetDesc2 to get the + // actual hardware values if possible. + DXGI_ADAPTER_DESC2 adapterDesc2; + dxgiAdapter2->GetDesc2(&adapterDesc2); + adapterString = std::wstring(adapterDesc2.Description); + } + else + { + DXGI_ADAPTER_DESC adapterDesc; + dxgiAdapter->GetDesc(&adapterDesc); + adapterString = std::wstring(adapterDesc.Description); + } + + // Both Reference and Software adapters will be 'Software Adapter' + const bool isSoftwareDevice = + (adapterString.find(std::wstring(L"Software Adapter")) != std::string::npos); + const bool isNullDevice = (adapterString == L""); + const bool isWARPDevice = + (adapterString.find(std::wstring(L"Basic Render")) != std::string::npos); + + if (isSoftwareDevice || isNullDevice) + { + ASSERT(!isWARPDevice); + retDeviceType = ANGLE_D3D11_DEVICE_TYPE_SOFTWARE_REF_OR_NULL; + } + else if (isWARPDevice) + { + retDeviceType = ANGLE_D3D11_DEVICE_TYPE_WARP; + } + else + { + retDeviceType = ANGLE_D3D11_DEVICE_TYPE_HARDWARE; + } + } + } + + SafeRelease(dxgiDevice); + SafeRelease(dxgiAdapter); + SafeRelease(dxgiAdapter2); + + return retDeviceType; +} + +void MakeValidSize(bool isImage, + DXGI_FORMAT format, + GLsizei *requestWidth, + GLsizei *requestHeight, + int *levelOffset) +{ + const DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(format); + bool validFormat = format != DXGI_FORMAT_UNKNOWN; + bool validImage = isImage && validFormat; + + int upsampleCount = 0; + // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already. + if (validImage || *requestWidth < static_cast<GLsizei>(dxgiFormatInfo.blockWidth) || + *requestHeight < static_cast<GLsizei>(dxgiFormatInfo.blockHeight)) + { + while (*requestWidth % dxgiFormatInfo.blockWidth != 0 || + *requestHeight % dxgiFormatInfo.blockHeight != 0) + { + *requestWidth <<= 1; + *requestHeight <<= 1; + upsampleCount++; + } + } + else if (validFormat) + { + if (*requestWidth % dxgiFormatInfo.blockWidth != 0) + { + *requestWidth = roundUp(*requestWidth, static_cast<GLsizei>(dxgiFormatInfo.blockWidth)); + } + + if (*requestHeight % dxgiFormatInfo.blockHeight != 0) + { + *requestHeight = + roundUp(*requestHeight, static_cast<GLsizei>(dxgiFormatInfo.blockHeight)); + } + } + + if (levelOffset) + { + *levelOffset = upsampleCount; + } +} + +angle::Result GenerateInitialTextureData( + const gl::Context *context, + GLint internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + GLuint width, + GLuint height, + GLuint depth, + GLuint mipLevels, + gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> *outSubresourceData) +{ + const d3d11::Format &d3dFormatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); + ASSERT(d3dFormatInfo.dataInitializerFunction != nullptr); + + const d3d11::DXGIFormatSize &dxgiFormatInfo = + d3d11::GetDXGIFormatSizeInfo(d3dFormatInfo.texFormat); + + using CheckedSize = angle::CheckedNumeric<size_t>; + CheckedSize rowPitch = CheckedSize(dxgiFormatInfo.pixelBytes) * CheckedSize(width); + CheckedSize depthPitch = rowPitch * CheckedSize(height); + CheckedSize maxImageSize = depthPitch * CheckedSize(depth); + + Context11 *context11 = GetImplAs<Context11>(context); + ANGLE_CHECK_GL_ALLOC(context11, maxImageSize.IsValid()); + + angle::MemoryBuffer *scratchBuffer = nullptr; + ANGLE_CHECK_GL_ALLOC(context11, + context->getScratchBuffer(maxImageSize.ValueOrDie(), &scratchBuffer)); + + d3dFormatInfo.dataInitializerFunction(width, height, depth, scratchBuffer->data(), + rowPitch.ValueOrDie(), depthPitch.ValueOrDie()); + + for (unsigned int i = 0; i < mipLevels; i++) + { + unsigned int mipWidth = std::max(width >> i, 1U); + unsigned int mipHeight = std::max(height >> i, 1U); + + using CheckedUINT = angle::CheckedNumeric<UINT>; + CheckedUINT mipRowPitch = CheckedUINT(dxgiFormatInfo.pixelBytes) * CheckedUINT(mipWidth); + CheckedUINT mipDepthPitch = mipRowPitch * CheckedUINT(mipHeight); + + ANGLE_CHECK_GL_ALLOC(context11, mipRowPitch.IsValid() && mipDepthPitch.IsValid()); + + outSubresourceData->at(i).pSysMem = scratchBuffer->data(); + outSubresourceData->at(i).SysMemPitch = mipRowPitch.ValueOrDie(); + outSubresourceData->at(i).SysMemSlicePitch = mipDepthPitch.ValueOrDie(); + } + + return angle::Result::Continue; +} + +UINT GetPrimitiveRestartIndex() +{ + return std::numeric_limits<UINT>::max(); +} + +void SetPositionTexCoordVertex(PositionTexCoordVertex *vertex, float x, float y, float u, float v) +{ + vertex->x = x; + vertex->y = y; + vertex->u = u; + vertex->v = v; +} + +void SetPositionLayerTexCoord3DVertex(PositionLayerTexCoord3DVertex *vertex, + float x, + float y, + unsigned int layer, + float u, + float v, + float s) +{ + vertex->x = x; + vertex->y = y; + vertex->l = layer; + vertex->u = u; + vertex->v = v; + vertex->s = s; +} + +BlendStateKey::BlendStateKey() +{ + memset(this, 0, sizeof(BlendStateKey)); + blendStateExt = gl::BlendStateExt(); +} + +BlendStateKey::BlendStateKey(const BlendStateKey &other) +{ + memcpy(this, &other, sizeof(BlendStateKey)); +} + +bool operator==(const BlendStateKey &a, const BlendStateKey &b) +{ + return memcmp(&a, &b, sizeof(BlendStateKey)) == 0; +} + +bool operator!=(const BlendStateKey &a, const BlendStateKey &b) +{ + return !(a == b); +} + +RasterizerStateKey::RasterizerStateKey() +{ + memset(this, 0, sizeof(RasterizerStateKey)); +} + +bool operator==(const RasterizerStateKey &a, const RasterizerStateKey &b) +{ + return memcmp(&a, &b, sizeof(RasterizerStateKey)) == 0; +} + +bool operator!=(const RasterizerStateKey &a, const RasterizerStateKey &b) +{ + return !(a == b); +} + +HRESULT SetDebugName(ID3D11DeviceChild *resource, + const char *internalName, + const std::string *khrDebugName) +{ + // Prepend ANGLE to separate names from other components in the same process. + std::string d3dName = "ANGLE"; + bool sendNameToD3D = false; + if (internalName && internalName[0] != '\0') + { + d3dName += std::string("_") + internalName; + sendNameToD3D = true; + } + if (khrDebugName && !khrDebugName->empty()) + { + d3dName += std::string("_") + *khrDebugName; + sendNameToD3D = true; + } + // If both internalName and khrDebugName are empty, avoid sending the string to d3d. + if (sendNameToD3D) + { + return resource->SetPrivateData(WKPDID_D3DDebugObjectName, + static_cast<UINT>(d3dName.size()), d3dName.c_str()); + } + return S_OK; +} + +// Keep this in cpp file where it has visibility of Renderer11.h, otherwise calling +// allocateResource is only compatible with Clang and MSVS, which support calling a +// method on a forward declared class in a template. +template <ResourceType ResourceT> +angle::Result LazyResource<ResourceT>::resolveImpl(d3d::Context *context, + Renderer11 *renderer, + const GetDescType<ResourceT> &desc, + GetInitDataType<ResourceT> *initData, + const char *name) +{ + if (!mResource.valid()) + { + ANGLE_TRY(renderer->allocateResource(context, desc, initData, &mResource)); + mResource.setInternalName(name); + } + return angle::Result::Continue; +} + +template angle::Result LazyResource<ResourceType::BlendState>::resolveImpl( + d3d::Context *context, + Renderer11 *renderer, + const D3D11_BLEND_DESC &desc, + void *initData, + const char *name); +template angle::Result LazyResource<ResourceType::ComputeShader>::resolveImpl( + d3d::Context *context, + Renderer11 *renderer, + const ShaderData &desc, + void *initData, + const char *name); +template angle::Result LazyResource<ResourceType::GeometryShader>::resolveImpl( + d3d::Context *context, + Renderer11 *renderer, + const ShaderData &desc, + const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData, + const char *name); +template angle::Result LazyResource<ResourceType::InputLayout>::resolveImpl( + d3d::Context *context, + Renderer11 *renderer, + const InputElementArray &desc, + const ShaderData *initData, + const char *name); +template angle::Result LazyResource<ResourceType::PixelShader>::resolveImpl(d3d::Context *context, + Renderer11 *renderer, + const ShaderData &desc, + void *initData, + const char *name); +template angle::Result LazyResource<ResourceType::VertexShader>::resolveImpl(d3d::Context *context, + Renderer11 *renderer, + const ShaderData &desc, + void *initData, + const char *name); + +LazyInputLayout::LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc, + size_t inputDescLen, + const BYTE *byteCode, + size_t byteCodeLen, + const char *debugName) + : mInputDesc(inputDesc, inputDescLen), mByteCode(byteCode, byteCodeLen), mDebugName(debugName) +{} + +LazyInputLayout::~LazyInputLayout() {} + +angle::Result LazyInputLayout::resolve(d3d::Context *context, Renderer11 *renderer) +{ + return resolveImpl(context, renderer, mInputDesc, &mByteCode, mDebugName); +} + +LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName) + : mDesc(desc), mDebugName(debugName) +{} + +angle::Result LazyBlendState::resolve(d3d::Context *context, Renderer11 *renderer) +{ + return resolveImpl(context, renderer, mDesc, nullptr, mDebugName); +} + +void InitializeFeatures(const Renderer11DeviceCaps &deviceCaps, + const DXGI_ADAPTER_DESC &adapterDesc, + angle::FeaturesD3D *features) +{ + bool isNvidia = IsNvidia(adapterDesc.VendorId); + bool isIntel = IsIntel(adapterDesc.VendorId); + bool isSkylake = false; + bool isBroadwell = false; + bool isHaswell = false; + bool isIvyBridge = false; + bool isSandyBridge = false; + bool isAMD = IsAMD(adapterDesc.VendorId); + bool isFeatureLevel9_3 = (deviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3); + + IntelDriverVersion capsVersion = IntelDriverVersion(0); + if (isIntel) + { + capsVersion = d3d11_gl::GetIntelDriverVersion(deviceCaps.driverVersion); + + isSkylake = IsSkylake(adapterDesc.DeviceId); + isBroadwell = IsBroadwell(adapterDesc.DeviceId); + isHaswell = IsHaswell(adapterDesc.DeviceId); + isIvyBridge = IsIvyBridge(adapterDesc.DeviceId); + isSandyBridge = IsSandyBridge(adapterDesc.DeviceId); + } + + if (isNvidia) + { + // TODO(jmadill): Narrow problematic driver range. + bool driverVersionValid = deviceCaps.driverVersion.valid(); + if (driverVersionValid) + { + WORD part1 = HIWORD(deviceCaps.driverVersion.value().LowPart); + WORD part2 = LOWORD(deviceCaps.driverVersion.value().LowPart); + + // Disable the workaround to fix a second driver bug on newer NVIDIA. + ANGLE_FEATURE_CONDITION( + features, depthStencilBlitExtraCopy, + (part1 <= 13u && part2 < 6881) && isNvidia && driverVersionValid); + } + else + { + ANGLE_FEATURE_CONDITION(features, depthStencilBlitExtraCopy, + isNvidia && !driverVersionValid); + } + } + + ANGLE_FEATURE_CONDITION(features, mrtPerfWorkaround, true); + ANGLE_FEATURE_CONDITION(features, zeroMaxLodWorkaround, isFeatureLevel9_3); + ANGLE_FEATURE_CONDITION(features, useInstancedPointSpriteEmulation, isFeatureLevel9_3); + ANGLE_FEATURE_CONDITION(features, allowES3OnFL100, false); + + // TODO(jmadill): Disable workaround when we have a fixed compiler DLL. + ANGLE_FEATURE_CONDITION(features, expandIntegerPowExpressions, true); + + ANGLE_FEATURE_CONDITION(features, flushAfterEndingTransformFeedback, isNvidia); + ANGLE_FEATURE_CONDITION(features, getDimensionsIgnoresBaseLevel, isNvidia); + ANGLE_FEATURE_CONDITION(features, skipVSConstantRegisterZero, isNvidia); + ANGLE_FEATURE_CONDITION(features, forceAtomicValueResolution, isNvidia); + + ANGLE_FEATURE_CONDITION(features, preAddTexelFetchOffsets, isIntel); + ANGLE_FEATURE_CONDITION(features, useSystemMemoryForConstantBuffers, isIntel); + + // ClearView on Skylake seems to incorrectly clear with unaligned rects (edge has saw tooth + // pattern instead of straight). + ANGLE_FEATURE_CONDITION(features, scissoredClearArtifacts, isIntel && isSkylake); + + ANGLE_FEATURE_CONDITION(features, callClearTwice, + isIntel && isSkylake && capsVersion >= IntelDriverVersion(160000) && + capsVersion < IntelDriverVersion(164771)); + ANGLE_FEATURE_CONDITION(features, emulateIsnanFloat, + isIntel && isSkylake && capsVersion >= IntelDriverVersion(160000) && + capsVersion < IntelDriverVersion(164542)); + ANGLE_FEATURE_CONDITION(features, rewriteUnaryMinusOperator, + isIntel && (isBroadwell || isHaswell) && + capsVersion >= IntelDriverVersion(150000) && + capsVersion < IntelDriverVersion(154624)); + + ANGLE_FEATURE_CONDITION(features, addMockTextureNoRenderTarget, + isIntel && capsVersion >= IntelDriverVersion(160000) && + capsVersion < IntelDriverVersion(164815)); + + // Haswell drivers occasionally corrupt (small?) (vertex?) texture data uploads for 128bit + // formats. + ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUpload, true); + ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUploadOn128bitFormats, + !(isIvyBridge || isBroadwell || isHaswell)); + + ANGLE_FEATURE_CONDITION(features, emulateClearViewAfterDualSourceBlending, isSandyBridge); + + ANGLE_FEATURE_CONDITION(features, disableB5G6R5Support, + (isIntel && capsVersion >= IntelDriverVersion(150000) && + capsVersion < IntelDriverVersion(154539)) || + isAMD); + + // TODO(jmadill): Disable when we have a fixed driver version. + // The tiny stencil texture workaround involves using CopySubresource or UpdateSubresource on a + // depth stencil texture. This is not allowed until feature level 10.1 but since it is not + // possible to support ES3 on these devices, there is no need for the workaround to begin with + // (anglebug.com/1572). + ANGLE_FEATURE_CONDITION(features, emulateTinyStencilTextures, + isAMD && !(deviceCaps.featureLevel < D3D_FEATURE_LEVEL_10_1)); + + // If the VPAndRTArrayIndexFromAnyShaderFeedingRasterizer feature is not available, we have to + // select the viewport / RT array index in the geometry shader. + ANGLE_FEATURE_CONDITION(features, selectViewInGeometryShader, + !deviceCaps.supportsVpRtIndexWriteFromVertexShader); + + // NVidia drivers have no trouble clearing textures without showing corruption. + // Intel and AMD drivers that have trouble have been blocklisted by Chromium. In the case of + // Intel, they've been blocklisted to the DX9 runtime. + ANGLE_FEATURE_CONDITION(features, allowClearForRobustResourceInit, true); + + // Allow translating uniform block to StructuredBuffer on Windows 10. This is targeted + // to work around a slow fxc compile performance issue with dynamic uniform indexing. + ANGLE_FEATURE_CONDITION(features, allowTranslateUniformBlockToStructuredBuffer, + IsWin10OrGreater()); +} + +void InitializeFrontendFeatures(const DXGI_ADAPTER_DESC &adapterDesc, + angle::FrontendFeatures *features) +{ + bool isAMD = IsAMD(adapterDesc.VendorId); + + ANGLE_FEATURE_CONDITION(features, forceDepthAttachmentInitOnClear, isAMD); +} + +void InitConstantBufferDesc(D3D11_BUFFER_DESC *constantBufferDescription, size_t byteWidth) +{ + constantBufferDescription->ByteWidth = static_cast<UINT>(byteWidth); + constantBufferDescription->Usage = D3D11_USAGE_DYNAMIC; + constantBufferDescription->BindFlags = D3D11_BIND_CONSTANT_BUFFER; + constantBufferDescription->CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + constantBufferDescription->MiscFlags = 0; + constantBufferDescription->StructureByteStride = 0; +} + +} // namespace d3d11 + +// TextureHelper11 implementation. +TextureHelper11::TextureHelper11() : mFormatSet(nullptr), mSampleCount(0) {} + +TextureHelper11::TextureHelper11(TextureHelper11 &&toCopy) : TextureHelper11() +{ + *this = std::move(toCopy); +} + +TextureHelper11::TextureHelper11(const TextureHelper11 &other) + : mFormatSet(other.mFormatSet), mExtents(other.mExtents), mSampleCount(other.mSampleCount) +{ + mData = other.mData; +} + +TextureHelper11::~TextureHelper11() {} + +void TextureHelper11::getDesc(D3D11_TEXTURE2D_DESC *desc) const +{ + static_cast<ID3D11Texture2D *>(mData->object)->GetDesc(desc); +} + +void TextureHelper11::getDesc(D3D11_TEXTURE3D_DESC *desc) const +{ + static_cast<ID3D11Texture3D *>(mData->object)->GetDesc(desc); +} + +void TextureHelper11::getDesc(D3D11_BUFFER_DESC *desc) const +{ + static_cast<ID3D11Buffer *>(mData->object)->GetDesc(desc); +} + +void TextureHelper11::initDesc(const D3D11_TEXTURE2D_DESC &desc2D) +{ + mData->resourceType = ResourceType::Texture2D; + mExtents.width = static_cast<int>(desc2D.Width); + mExtents.height = static_cast<int>(desc2D.Height); + mExtents.depth = 1; + mSampleCount = desc2D.SampleDesc.Count; +} + +void TextureHelper11::initDesc(const D3D11_TEXTURE3D_DESC &desc3D) +{ + mData->resourceType = ResourceType::Texture3D; + mExtents.width = static_cast<int>(desc3D.Width); + mExtents.height = static_cast<int>(desc3D.Height); + mExtents.depth = static_cast<int>(desc3D.Depth); + mSampleCount = 1; +} + +void TextureHelper11::initDesc(const D3D11_BUFFER_DESC &descBuffer) +{ + mData->resourceType = ResourceType::Buffer; + mExtents.width = static_cast<int>(descBuffer.ByteWidth); + mExtents.height = 1; + mExtents.depth = 1; + mSampleCount = 1; +} + +TextureHelper11 &TextureHelper11::operator=(TextureHelper11 &&other) +{ + std::swap(mData, other.mData); + std::swap(mExtents, other.mExtents); + std::swap(mFormatSet, other.mFormatSet); + std::swap(mSampleCount, other.mSampleCount); + return *this; +} + +TextureHelper11 &TextureHelper11::operator=(const TextureHelper11 &other) +{ + mData = other.mData; + mExtents = other.mExtents; + mFormatSet = other.mFormatSet; + mSampleCount = other.mSampleCount; + return *this; +} + +bool TextureHelper11::operator==(const TextureHelper11 &other) const +{ + return mData->object == other.mData->object; +} + +bool TextureHelper11::operator!=(const TextureHelper11 &other) const +{ + return mData->object != other.mData->object; +} + +bool UsePresentPathFast(const Renderer11 *renderer, + const gl::FramebufferAttachment *framebufferAttachment) +{ + if (framebufferAttachment == nullptr) + { + return false; + } + + return (framebufferAttachment->type() == GL_FRAMEBUFFER_DEFAULT && + renderer->presentPathFastEnabled()); +} + +bool UsePrimitiveRestartWorkaround(bool primitiveRestartFixedIndexEnabled, + gl::DrawElementsType type) +{ + // We should never have to deal with primitive restart workaround issue with GL_UNSIGNED_INT + // indices, since we restrict it via MAX_ELEMENT_INDEX. + return (!primitiveRestartFixedIndexEnabled && type == gl::DrawElementsType::UnsignedShort); +} + +IndexStorageType ClassifyIndexStorage(const gl::State &glState, + const gl::Buffer *elementArrayBuffer, + gl::DrawElementsType elementType, + gl::DrawElementsType destElementType, + unsigned int offset) +{ + // No buffer bound means we are streaming from a client pointer. + if (!elementArrayBuffer || !IsOffsetAligned(elementType, offset)) + { + return IndexStorageType::Dynamic; + } + + // The buffer can be used directly if the storage supports it and no translation needed. + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(elementArrayBuffer); + if (bufferD3D->supportsDirectBinding() && destElementType == elementType) + { + return IndexStorageType::Direct; + } + + // Use a static copy when available. + StaticIndexBufferInterface *staticBuffer = bufferD3D->getStaticIndexBuffer(); + if (staticBuffer != nullptr) + { + return IndexStorageType::Static; + } + + // Static buffer not available, fall back to streaming. + return IndexStorageType::Dynamic; +} + +bool SwizzleRequired(const gl::TextureState &textureState) +{ + // When sampling stencil, a swizzle is needed to move the stencil channel from G to R. + return textureState.swizzleRequired() || textureState.isStencilMode(); +} + +gl::SwizzleState GetEffectiveSwizzle(const gl::TextureState &textureState) +{ + const gl::SwizzleState &swizzle = textureState.getSwizzleState(); + if (textureState.isStencilMode()) + { + // Per GL semantics, the stencil value should be in the red channel, while D3D11 formats + // leave stencil in the green channel. So copy the stencil value from green to all + // components requesting red. Green and blue become zero; alpha becomes one. + std::unordered_map<GLenum, GLenum> map = {{GL_RED, GL_GREEN}, {GL_GREEN, GL_ZERO}, + {GL_BLUE, GL_ZERO}, {GL_ALPHA, GL_ONE}, + {GL_ZERO, GL_ZERO}, {GL_ONE, GL_ONE}}; + + return gl::SwizzleState(map[swizzle.swizzleRed], map[swizzle.swizzleGreen], + map[swizzle.swizzleBlue], map[swizzle.swizzleAlpha]); + } + return swizzle; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h new file mode 100644 index 0000000000..a8cd430bc6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h @@ -0,0 +1,478 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// renderer11_utils.h: Conversion functions and other utility routines +// specific to the D3D11 renderer. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_UTILS_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_UTILS_H_ + +#include <array> +#include <functional> +#include <vector> + +#include "common/Color.h" + +#include "libANGLE/Caps.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +namespace gl +{ +class FramebufferAttachment; +} + +namespace rx +{ +class Context11; +class Renderer11; +class RenderTarget11; +struct Renderer11DeviceCaps; + +using RTVArray = std::array<ID3D11RenderTargetView *, gl::IMPLEMENTATION_MAX_DRAW_BUFFERS>; + +namespace gl_d3d11 +{ + +D3D11_BLEND ConvertBlendFunc(GLenum glBlend, bool isAlpha); +D3D11_BLEND_OP ConvertBlendOp(GLenum glBlendOp); +UINT8 ConvertColorMask(bool maskRed, bool maskGreen, bool maskBlue, bool maskAlpha); + +D3D11_CULL_MODE ConvertCullMode(bool cullEnabled, gl::CullFaceMode cullMode); + +D3D11_COMPARISON_FUNC ConvertComparison(GLenum comparison); +D3D11_DEPTH_WRITE_MASK ConvertDepthMask(bool depthWriteEnabled); +UINT8 ConvertStencilMask(GLuint stencilmask); +D3D11_STENCIL_OP ConvertStencilOp(GLenum stencilOp); + +D3D11_FILTER ConvertFilter(GLenum minFilter, + GLenum magFilter, + float maxAnisotropy, + GLenum comparisonMode); +D3D11_TEXTURE_ADDRESS_MODE ConvertTextureWrap(GLenum wrap); +UINT ConvertMaxAnisotropy(float maxAnisotropy, D3D_FEATURE_LEVEL featureLevel); + +D3D11_QUERY ConvertQueryType(gl::QueryType type); + +UINT8 GetColorMask(const gl::InternalFormat &formatInfo); + +} // namespace gl_d3d11 + +namespace d3d11_gl +{ + +unsigned int GetReservedVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel); + +unsigned int GetReservedFragmentUniformVectors(D3D_FEATURE_LEVEL featureLevel); + +gl::Version GetMaximumClientVersion(const Renderer11DeviceCaps &caps); +void GenerateCaps(ID3D11Device *device, + ID3D11DeviceContext *deviceContext, + const Renderer11DeviceCaps &renderer11DeviceCaps, + const angle::FeaturesD3D &features, + const char *description, + gl::Caps *caps, + gl::TextureCapsMap *textureCapsMap, + gl::Extensions *extensions, + gl::Limitations *limitations); + +D3D_FEATURE_LEVEL GetMinimumFeatureLevelForES31(); + +} // namespace d3d11_gl + +namespace d3d11 +{ + +enum ANGLED3D11DeviceType +{ + ANGLE_D3D11_DEVICE_TYPE_UNKNOWN, + ANGLE_D3D11_DEVICE_TYPE_HARDWARE, + ANGLE_D3D11_DEVICE_TYPE_SOFTWARE_REF_OR_NULL, + ANGLE_D3D11_DEVICE_TYPE_WARP, +}; + +ANGLED3D11DeviceType GetDeviceType(ID3D11Device *device); + +void MakeValidSize(bool isImage, + DXGI_FORMAT format, + GLsizei *requestWidth, + GLsizei *requestHeight, + int *levelOffset); + +angle::Result GenerateInitialTextureData( + const gl::Context *context, + GLint internalFormat, + const Renderer11DeviceCaps &renderer11DeviceCaps, + GLuint width, + GLuint height, + GLuint depth, + GLuint mipLevels, + gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> *outSubresourceData); + +UINT GetPrimitiveRestartIndex(); + +struct PositionTexCoordVertex +{ + float x, y; + float u, v; +}; +void SetPositionTexCoordVertex(PositionTexCoordVertex *vertex, float x, float y, float u, float v); + +struct PositionLayerTexCoord3DVertex +{ + float x, y; + unsigned int l; + float u, v, s; +}; +void SetPositionLayerTexCoord3DVertex(PositionLayerTexCoord3DVertex *vertex, + float x, + float y, + unsigned int layer, + float u, + float v, + float s); + +struct PositionVertex +{ + float x, y, z, w; +}; + +struct BlendStateKey final +{ + // This will zero-initialize the struct, including padding. + BlendStateKey(); + BlendStateKey(const BlendStateKey &other); + + gl::BlendStateExt blendStateExt; + + // Use two 16-bit ints to round the struct nicely. + uint16_t rtvMax; + uint16_t sampleAlphaToCoverage; +}; + +bool operator==(const BlendStateKey &a, const BlendStateKey &b); +bool operator!=(const BlendStateKey &a, const BlendStateKey &b); + +struct RasterizerStateKey final +{ + // This will zero-initialize the struct, including padding. + RasterizerStateKey(); + + gl::RasterizerState rasterizerState; + + // Use a 32-bit int to round the struct nicely. + uint32_t scissorEnabled; +}; + +bool operator==(const RasterizerStateKey &a, const RasterizerStateKey &b); +bool operator!=(const RasterizerStateKey &a, const RasterizerStateKey &b); + +template <typename outType> +outType *DynamicCastComObject(IUnknown *object) +{ + outType *outObject = nullptr; + HRESULT result = + object->QueryInterface(__uuidof(outType), reinterpret_cast<void **>(&outObject)); + if (SUCCEEDED(result)) + { + return outObject; + } + else + { + SafeRelease(outObject); + return nullptr; + } +} + +template <typename outType> +angle::ComPtr<outType> DynamicCastComObjectToComPtr(IUnknown *object) +{ + angle::ComPtr<outType> outObject; + const HRESULT hr = object->QueryInterface(IID_PPV_ARGS(&outObject)); + if (SUCCEEDED(hr)) + { + return outObject; + } + else + { + return nullptr; + } +} + +inline bool isDeviceLostError(HRESULT errorCode) +{ + switch (errorCode) + { + case DXGI_ERROR_DEVICE_HUNG: + case DXGI_ERROR_DEVICE_REMOVED: + case DXGI_ERROR_DEVICE_RESET: + case DXGI_ERROR_DRIVER_INTERNAL_ERROR: + case DXGI_ERROR_NOT_CURRENTLY_AVAILABLE: + return true; + default: + return false; + } +} + +template <ResourceType ResourceT> +class LazyResource : angle::NonCopyable +{ + public: + constexpr LazyResource() : mResource() {} + virtual ~LazyResource() {} + + virtual angle::Result resolve(d3d::Context *context, Renderer11 *renderer) = 0; + void reset() { mResource.reset(); } + GetD3D11Type<ResourceT> *get() const + { + ASSERT(mResource.valid()); + return mResource.get(); + } + + const Resource11<GetD3D11Type<ResourceT>> &getObj() const { return mResource; } + + protected: + LazyResource(LazyResource &&other) : mResource(std::move(other.mResource)) {} + + // Specialized in the cpp file to avoid MSVS/Clang specific code. + angle::Result resolveImpl(d3d::Context *context, + Renderer11 *renderer, + const GetDescType<ResourceT> &desc, + GetInitDataType<ResourceT> *initData, + const char *name); + + Resource11<GetD3D11Type<ResourceT>> mResource; +}; + +template <typename D3D11ShaderType> +class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()> +{ + public: + // All parameters must be constexpr. Not supported in VS2013. + constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name) + : mByteCode(byteCode, byteCodeSize), mName(name) + {} + + constexpr LazyShader(LazyShader &&shader) + : LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>(std::move(shader)), + mByteCode(std::move(shader.mByteCode)), + mName(shader.mName) + {} + + angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override + { + return this->resolveImpl(context, renderer, mByteCode, nullptr, mName); + } + + private: + ShaderData mByteCode; + const char *mName; +}; + +class LazyInputLayout final : public LazyResource<ResourceType::InputLayout> +{ + public: + LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc, + size_t inputDescLen, + const BYTE *byteCode, + size_t byteCodeLen, + const char *debugName); + ~LazyInputLayout() override; + + angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override; + + private: + InputElementArray mInputDesc; + ShaderData mByteCode; + const char *mDebugName; +}; + +class LazyBlendState final : public LazyResource<ResourceType::BlendState> +{ + public: + LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName); + + angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override; + + private: + D3D11_BLEND_DESC mDesc; + const char *mDebugName; +}; + +// Copy data to small D3D11 buffers, such as for small constant buffers, which use one struct to +// represent an entire buffer. +template <class T> +void SetBufferData(ID3D11DeviceContext *context, ID3D11Buffer *constantBuffer, const T &value) +{ + D3D11_MAPPED_SUBRESOURCE mappedResource = {}; + HRESULT result = context->Map(constantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + ASSERT(SUCCEEDED(result)); + if (SUCCEEDED(result)) + { + memcpy(mappedResource.pData, &value, sizeof(T)); + context->Unmap(constantBuffer, 0); + } +} + +void InitializeFeatures(const Renderer11DeviceCaps &deviceCaps, + const DXGI_ADAPTER_DESC &adapterDesc, + angle::FeaturesD3D *features); + +void InitializeFrontendFeatures(const DXGI_ADAPTER_DESC &adapterDesc, + angle::FrontendFeatures *features); + +enum ReservedConstantBufferSlot +{ + RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK = 0, + RESERVED_CONSTANT_BUFFER_SLOT_DRIVER = 1, + + RESERVED_CONSTANT_BUFFER_SLOT_COUNT = 2 +}; + +void InitConstantBufferDesc(D3D11_BUFFER_DESC *constantBufferDescription, size_t byteWidth); + +// Helper class for RAII patterning. +template <typename T> +class [[nodiscard]] ScopedUnmapper final : angle::NonCopyable +{ + public: + ScopedUnmapper(T *object) : mObject(object) {} + ~ScopedUnmapper() { mObject->unmap(); } + + private: + T *mObject; +}; +} // namespace d3d11 + +struct GenericData +{ + GenericData() {} + ~GenericData() + { + if (object) + { + // We can have a nullptr factory when holding passed-in resources. + if (manager) + { + manager->onReleaseGeneric(resourceType, object); + manager = nullptr; + } + object->Release(); + object = nullptr; + } + } + + ResourceType resourceType = ResourceType::Last; + ID3D11Resource *object = nullptr; + ResourceManager11 *manager = nullptr; +}; + +// A helper class which wraps a 2D or 3D texture. +class TextureHelper11 : public Resource11Base<ID3D11Resource, std::shared_ptr, GenericData> +{ + public: + TextureHelper11(); + TextureHelper11(TextureHelper11 &&other); + TextureHelper11(const TextureHelper11 &other); + ~TextureHelper11() override; + TextureHelper11 &operator=(TextureHelper11 &&other); + TextureHelper11 &operator=(const TextureHelper11 &other); + + bool isBuffer() const { return mData->resourceType == ResourceType::Buffer; } + bool is2D() const { return mData->resourceType == ResourceType::Texture2D; } + bool is3D() const { return mData->resourceType == ResourceType::Texture3D; } + ResourceType getTextureType() const { return mData->resourceType; } + gl::Extents getExtents() const { return mExtents; } + DXGI_FORMAT getFormat() const { return mFormatSet->texFormat; } + const d3d11::Format &getFormatSet() const { return *mFormatSet; } + int getSampleCount() const { return mSampleCount; } + + template <typename DescT, typename ResourceT> + void init(Resource11<ResourceT> &&texture, const DescT &desc, const d3d11::Format &format) + { + std::swap(mData->manager, texture.mData->manager); + + // Can't use std::swap because texture is typed, and here we use ID3D11Resource. + ID3D11Resource *temp = mData->object; + mData->object = texture.mData->object; + texture.mData->object = static_cast<ResourceT *>(temp); + + mFormatSet = &format; + initDesc(desc); + } + + template <typename ResourceT> + void set(ResourceT *object, const d3d11::Format &format) + { + ASSERT(!valid()); + + mFormatSet = &format; + mData->object = object; + mData->manager = nullptr; + + GetDescFromD3D11<ResourceT> desc; + getDesc(&desc); + initDesc(desc); + } + + bool operator==(const TextureHelper11 &other) const; + bool operator!=(const TextureHelper11 &other) const; + + void getDesc(D3D11_TEXTURE2D_DESC *desc) const; + void getDesc(D3D11_TEXTURE3D_DESC *desc) const; + void getDesc(D3D11_BUFFER_DESC *desc) const; + + private: + void initDesc(const D3D11_TEXTURE2D_DESC &desc2D); + void initDesc(const D3D11_TEXTURE3D_DESC &desc3D); + void initDesc(const D3D11_BUFFER_DESC &descBuffer); + + const d3d11::Format *mFormatSet; + gl::Extents mExtents; + int mSampleCount; +}; + +enum class StagingAccess +{ + READ, + READ_WRITE, +}; + +bool UsePresentPathFast(const Renderer11 *renderer, const gl::FramebufferAttachment *colorbuffer); +bool UsePrimitiveRestartWorkaround(bool primitiveRestartFixedIndexEnabled, + gl::DrawElementsType type); + +enum class IndexStorageType +{ + // Dynamic indexes are re-streamed every frame. They come from a client data pointer or + // from buffers that are updated frequently. + Dynamic, + + // Static indexes are translated from the original storage once, and re-used multiple times. + Static, + + // Direct indexes are never transated and are used directly from the source buffer. They are + // the fastest available path. + Direct, + + // Not a real storage type. + Invalid, +}; + +IndexStorageType ClassifyIndexStorage(const gl::State &glState, + const gl::Buffer *elementArrayBuffer, + gl::DrawElementsType elementType, + gl::DrawElementsType destElementType, + unsigned int offset); + +bool SwizzleRequired(const gl::TextureState &textureState); +gl::SwizzleState GetEffectiveSwizzle(const gl::TextureState &textureState); + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_UTILS_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h new file mode 100644 index 0000000000..9bfc750765 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 x 1 NONE uint x +// LAYER 0 y 1 NONE uint y +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 x 1 NONE uint x +// SV_RenderTargetArrayIndex 0 y 1 RTINDEX uint y +// +gs_4_0 +dcl_input_siv v[1][0].xyzw, position +dcl_input v[1][1].x +dcl_input v[1][1].y +dcl_inputprimitive point +dcl_outputtopology pointlist +dcl_output_siv o0.xyzw, position +dcl_output o1.x +dcl_output_siv o1.y, rendertarget_array_index +dcl_maxout 1 +mov o0.xyzw, v[0][0].xyzw +mov o1.x, v[0][1].x +mov o1.y, v[0][1].y +emit +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_GS_BufferToTexture[] = { + 68, 88, 66, 67, 181, 104, 45, 14, 26, 142, 216, 235, 63, 167, 110, 6, 1, 170, 134, + 100, 1, 0, 0, 0, 200, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 244, 0, 0, 0, 124, 1, 0, 0, 76, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 83, 71, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 108, + 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 92, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, + 0, 0, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, + 0, 0, 0, 2, 2, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, + 84, 69, 88, 67, 79, 79, 82, 68, 0, 76, 65, 89, 69, 82, 0, 171, 79, 83, 71, + 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 1, 14, 0, 0, 101, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 2, 13, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, + 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 83, 86, 95, 82, 101, 110, 100, 101, + 114, 84, 97, 114, 103, 101, 116, 65, 114, 114, 97, 121, 73, 110, 100, 101, 120, 0, 171, + 83, 72, 68, 82, 200, 0, 0, 0, 64, 0, 2, 0, 50, 0, 0, 0, 97, 0, 0, + 5, 242, 16, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 95, 0, + 0, 4, 18, 16, 32, 0, 1, 0, 0, 0, 1, 0, 0, 0, 95, 0, 0, 4, 34, + 16, 32, 0, 1, 0, 0, 0, 1, 0, 0, 0, 93, 8, 0, 1, 92, 8, 0, 1, + 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, 1, 0, 0, 0, 101, 0, 0, + 3, 18, 32, 16, 0, 1, 0, 0, 0, 103, 0, 0, 4, 34, 32, 16, 0, 1, 0, + 0, 0, 4, 0, 0, 0, 94, 0, 0, 2, 1, 0, 0, 0, 54, 0, 0, 6, 242, + 32, 16, 0, 0, 0, 0, 0, 70, 30, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 6, 18, 32, 16, 0, 1, 0, 0, 0, 10, 16, 32, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 54, 0, 0, 6, 34, 32, 16, 0, 1, 0, 0, 0, 26, 16, + 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 19, 0, 0, 1, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4f.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4f.h new file mode 100644 index 0000000000..87730ffe5c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4f.h @@ -0,0 +1,65 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Buffer4F texture float4 buf t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 x 1 NONE uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_resource_buffer (float,float,float,float) t0 +dcl_input_ps constant v1.x +dcl_output o0.xyzw +ld o0.xyzw, v1.xxxx, t0.xyzw +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_BufferToTexture_4F[] = { + 68, 88, 66, 67, 156, 38, 137, 246, 11, 113, 21, 186, 20, 101, 47, 15, 216, 211, 176, + 224, 1, 0, 0, 0, 12, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 144, 1, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 1, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 66, 117, 102, 102, 101, 114, 52, 70, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 80, 0, 0, 0, 64, 0, 0, + 0, 20, 0, 0, 0, 88, 8, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, + 0, 0, 98, 8, 0, 3, 18, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4i.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4i.h new file mode 100644 index 0000000000..64304f956d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4i.h @@ -0,0 +1,65 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Buffer4I texture sint4 buf t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 x 1 NONE uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_buffer (sint,sint,sint,sint) t0 +dcl_input_ps constant v1.x +dcl_output o0.xyzw +ld o0.xyzw, v1.xxxx, t0.xyzw +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_BufferToTexture_4I[] = { + 68, 88, 66, 67, 162, 203, 46, 4, 155, 72, 142, 126, 228, 80, 83, 117, 139, 11, 48, + 250, 1, 0, 0, 0, 12, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 144, 1, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 1, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 66, 117, 102, 102, 101, 114, 52, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 80, 0, 0, 0, 64, 0, 0, + 0, 20, 0, 0, 0, 88, 8, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, + 0, 0, 98, 8, 0, 3, 18, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4ui.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4ui.h new file mode 100644 index 0000000000..9504753bde --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_ps_4ui.h @@ -0,0 +1,65 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Buffer4UI texture uint4 buf t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 x 1 NONE uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_buffer (uint,uint,uint,uint) t0 +dcl_input_ps constant v1.x +dcl_output o0.xyzw +ld o0.xyzw, v1.xxxx, t0.xyzw +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_BufferToTexture_4UI[] = { + 68, 88, 66, 67, 168, 39, 110, 5, 143, 0, 75, 136, 251, 25, 27, 24, 35, 191, 3, + 64, 1, 0, 0, 0, 12, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 144, 1, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 1, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 66, 117, 102, 102, 101, 114, 52, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 80, 0, 0, 0, 64, 0, 0, + 0, 20, 0, 0, 0, 88, 8, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, + 0, 0, 98, 8, 0, 3, 18, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, + 6, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_vs.h new file mode 100644 index 0000000000..b9ce502123 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_vs.h @@ -0,0 +1,145 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer BufferCopyParams +// { +// +// uint FirstPixelOffset; // Offset: 0 Size: 4 +// uint PixelsPerRow; // Offset: 4 Size: 4 +// uint RowStride; // Offset: 8 Size: 4 +// uint RowsPerSlice; // Offset: 12 Size: 4 +// float2 PositionOffset; // Offset: 16 Size: 8 +// float2 PositionScale; // Offset: 24 Size: 8 +// int2 TexLocationOffset; // Offset: 32 Size: 8 [unused] +// int2 TexLocationScale; // Offset: 40 Size: 8 [unused] +// uint FirstSlice; // Offset: 48 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// BufferCopyParams cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_VertexID 0 x 0 VERTID uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 x 1 NONE uint x +// LAYER 0 y 1 NONE uint y +// +vs_4_0 +dcl_constantbuffer CB0[4], immediateIndexed +dcl_input_sgv v0.x, vertex_id +dcl_output_siv o0.xyzw, position +dcl_output o1.x +dcl_output o1.y +dcl_temps 2 +mov o0.zw, l(0,0,0,1.000000) +imul null, r0.xy, cb0[0].wwww, cb0[0].yzyy +udiv r0.z, null, v0.x, r0.x +imad r0.x, -r0.z, r0.x, v0.x +imad r0.y, r0.z, r0.y, cb0[0].x +iadd o1.y, r0.z, cb0[3].x +udiv r0.z, null, r0.x, cb0[0].y +imad r0.x, -r0.z, cb0[0].y, r0.x +utof r1.xy, r0.xzxx +imad r0.y, r0.z, cb0[0].z, r0.y +iadd o1.x, r0.x, r0.y +mad o0.xy, cb0[1].zwzz, r1.xyxx, cb0[1].xyxx +ret +// Approximately 13 instruction slots used +#endif + +const BYTE g_VS_BufferToTexture[] = { + 68, 88, 66, 67, 153, 33, 196, 57, 209, 115, 237, 17, 59, 231, 206, 105, 1, 81, 121, + 39, 1, 0, 0, 0, 140, 5, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 88, 2, + 0, 0, 140, 2, 0, 0, 0, 3, 0, 0, 16, 5, 0, 0, 82, 68, 69, 70, 28, + 2, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 254, 255, 0, 1, 0, 0, 244, 1, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 66, 117, 102, 102, 101, 114, 67, 111, 112, 121, 80, 97, 114, + 97, 109, 115, 0, 171, 171, 171, 60, 0, 0, 0, 9, 0, 0, 0, 104, 0, 0, 0, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 2, 0, 0, 0, 84, 1, 0, 0, 0, 0, 0, 0, 100, 1, + 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 84, 1, 0, 0, 0, + 0, 0, 0, 113, 1, 0, 0, 8, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, + 84, 1, 0, 0, 0, 0, 0, 0, 123, 1, 0, 0, 12, 0, 0, 0, 4, 0, 0, + 0, 2, 0, 0, 0, 84, 1, 0, 0, 0, 0, 0, 0, 136, 1, 0, 0, 16, 0, + 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 152, 1, 0, 0, 0, 0, 0, 0, 168, + 1, 0, 0, 24, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 152, 1, 0, 0, + 0, 0, 0, 0, 182, 1, 0, 0, 32, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 200, 1, 0, 0, 0, 0, 0, 0, 216, 1, 0, 0, 40, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 200, 1, 0, 0, 0, 0, 0, 0, 233, 1, 0, 0, 48, + 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 84, 1, 0, 0, 0, 0, 0, 0, + 70, 105, 114, 115, 116, 80, 105, 120, 101, 108, 79, 102, 102, 115, 101, 116, 0, 171, 171, + 171, 0, 0, 19, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 105, + 120, 101, 108, 115, 80, 101, 114, 82, 111, 119, 0, 82, 111, 119, 83, 116, 114, 105, 100, + 101, 0, 82, 111, 119, 115, 80, 101, 114, 83, 108, 105, 99, 101, 0, 80, 111, 115, 105, + 116, 105, 111, 110, 79, 102, 102, 115, 101, 116, 0, 171, 1, 0, 3, 0, 1, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 111, 115, 105, 116, 105, 111, 110, 83, 99, + 97, 108, 101, 0, 84, 101, 120, 76, 111, 99, 97, 116, 105, 111, 110, 79, 102, 102, 115, + 101, 116, 0, 1, 0, 2, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 84, 101, 120, 76, 111, 99, 97, 116, 105, 111, 110, 83, 99, 97, 108, 101, 0, 70, 105, + 114, 115, 116, 83, 108, 105, 99, 101, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, + 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, 0, + 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 86, 101, 114, + 116, 101, 120, 73, 68, 0, 79, 83, 71, 78, 108, 0, 0, 0, 3, 0, 0, 0, 8, + 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 14, 0, 0, 101, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 13, 0, 0, 83, + 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, + 0, 76, 65, 89, 69, 82, 0, 171, 83, 72, 68, 82, 8, 2, 0, 0, 64, 0, 1, + 0, 130, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 96, 0, 0, 4, 18, 16, 16, 0, 0, 0, 0, 0, 6, 0, 0, 0, 103, + 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, 1, 0, 0, 0, 101, 0, 0, 3, + 18, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 34, 32, 16, 0, 1, 0, 0, + 0, 104, 0, 0, 2, 2, 0, 0, 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 63, 38, 0, 0, 10, 0, 208, 0, 0, 50, 0, 16, 0, 0, 0, 0, 0, + 246, 143, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 150, 133, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 78, 0, 0, 8, 66, 0, 16, 0, 0, 0, 0, 0, 0, 208, + 0, 0, 10, 16, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 35, + 0, 0, 10, 18, 0, 16, 0, 0, 0, 0, 0, 42, 0, 16, 128, 65, 0, 0, 0, + 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 0, 0, 0, + 0, 35, 0, 0, 10, 34, 0, 16, 0, 0, 0, 0, 0, 42, 0, 16, 0, 0, 0, + 0, 0, 26, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 30, 0, 0, 8, 34, 32, 16, 0, 1, 0, 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 3, 0, 0, 0, 78, 0, 0, + 9, 66, 0, 16, 0, 0, 0, 0, 0, 0, 208, 0, 0, 10, 0, 16, 0, 0, 0, + 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 11, 18, + 0, 16, 0, 0, 0, 0, 0, 42, 0, 16, 128, 65, 0, 0, 0, 0, 0, 0, 0, + 26, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 86, 0, 0, 5, 50, 0, 16, 0, 1, 0, 0, 0, 134, 0, 16, 0, 0, 0, + 0, 0, 35, 0, 0, 10, 34, 0, 16, 0, 0, 0, 0, 0, 42, 0, 16, 0, 0, + 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 16, 0, + 0, 0, 0, 0, 30, 0, 0, 7, 18, 32, 16, 0, 1, 0, 0, 0, 10, 0, 16, + 0, 0, 0, 0, 0, 26, 0, 16, 0, 0, 0, 0, 0, 50, 0, 0, 11, 50, 32, + 16, 0, 0, 0, 0, 0, 230, 138, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 70, + 0, 16, 0, 1, 0, 0, 0, 70, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 13, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11_fl9vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11_fl9vs.h new file mode 100644 index 0000000000..9b4ccfb902 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11_fl9vs.h @@ -0,0 +1,71 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// POSITION 0 xyzw 0 NONE float xyzw +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// +// +// Runtime generated constant mappings: +// +// Target Reg Constant Description +// ---------- -------------------------------------------------- +// c0 Vertex Shader position offset +// +// +// Level9 shader bytecode: +// + vs_2_x + dcl_texcoord v0 + mad oPos.xy, v0.w, c0, v0 + mov oPos.zw, v0 + +// approximately 2 instruction slots used +vs_4_0 +dcl_input v0.xyzw +dcl_output_siv o0.xyzw, position +mov o0.xyzw, v0.xyzw +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_VS_Clear_FL9[] = { + 68, 88, 66, 67, 166, 109, 78, 113, 107, 98, 65, 70, 91, 88, 250, 161, 103, 22, 241, 76, + 1, 0, 0, 0, 16, 2, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 156, 0, 0, 0, + 224, 0, 0, 0, 92, 1, 0, 0, 168, 1, 0, 0, 220, 1, 0, 0, 65, 111, 110, 57, + 92, 0, 0, 0, 92, 0, 0, 0, 0, 2, 254, 255, 52, 0, 0, 0, 40, 0, 0, 0, + 0, 0, 36, 0, 0, 0, 36, 0, 0, 0, 36, 0, 0, 0, 36, 0, 1, 0, 36, 0, + 0, 0, 0, 0, 1, 2, 254, 255, 31, 0, 0, 2, 5, 0, 0, 128, 0, 0, 15, 144, + 4, 0, 0, 4, 0, 0, 3, 192, 0, 0, 255, 144, 0, 0, 228, 160, 0, 0, 228, 144, + 1, 0, 0, 2, 0, 0, 12, 192, 0, 0, 228, 144, 255, 255, 0, 0, 83, 72, 68, 82, + 60, 0, 0, 0, 64, 0, 1, 0, 15, 0, 0, 0, 95, 0, 0, 3, 242, 16, 16, 0, + 0, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 54, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 30, 16, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 4, 254, 255, 0, 1, 0, 0, + 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, + 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 15, 0, 0, 80, 79, 83, 73, 84, 73, 79, 78, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewgs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewgs.h new file mode 100644 index 0000000000..92b192107b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewgs.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 x 1 NONE uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// SV_RenderTargetArrayIndex 0 x 1 RTINDEX uint x +// +gs_4_0 +dcl_input_siv v[3][0].xyzw, position +dcl_input v[3][1].x +dcl_temps 1 +dcl_inputprimitive triangle +dcl_outputtopology trianglestrip +dcl_output_siv o0.xyzw, position +dcl_output_siv o1.x, rendertarget_array_index +dcl_maxout 3 +mov r0.x, l(0) +loop + ige r0.y, r0.x, l(3) + breakc_nz r0.y + mov o0.xyzw, v[r0.x + 0][0].xyzw + mov o1.x, v[r0.x + 0][1].x + emit + iadd r0.x, r0.x, l(1) +endloop +cut +ret +// Approximately 11 instruction slots used +#endif + +const BYTE g_GS_Multiview_Clear[] = { + 68, 88, 66, 67, 110, 37, 141, 207, 15, 59, 27, 66, 207, 215, 205, 198, 147, 31, 42, + 22, 1, 0, 0, 0, 204, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 216, 0, 0, 0, 64, 1, 0, 0, 80, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 83, 71, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 80, + 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, + 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, + 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 96, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 14, 0, 0, 83, 86, 95, 80, 111, + 115, 105, 116, 105, 111, 110, 0, 83, 86, 95, 82, 101, 110, 100, 101, 114, 84, 97, 114, + 103, 101, 116, 65, 114, 114, 97, 121, 73, 110, 100, 101, 120, 0, 171, 171, 83, 72, 68, + 82, 8, 1, 0, 0, 64, 0, 2, 0, 66, 0, 0, 0, 97, 0, 0, 5, 242, 16, + 32, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 95, 0, 0, 4, 18, + 16, 32, 0, 3, 0, 0, 0, 1, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, + 93, 24, 0, 1, 92, 40, 0, 1, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 103, 0, 0, 4, 18, 32, 16, 0, 1, 0, 0, 0, 4, 0, + 0, 0, 94, 0, 0, 2, 3, 0, 0, 0, 54, 0, 0, 5, 18, 0, 16, 0, 0, + 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 48, 0, 0, 1, 33, 0, 0, 7, + 34, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, + 0, 3, 0, 0, 0, 3, 0, 4, 3, 26, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, 70, 30, 160, 0, 10, 0, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 1, 0, 0, 0, + 10, 16, 160, 0, 10, 0, 16, 0, 0, 0, 0, 0, 1, 0, 0, 0, 19, 0, 0, + 1, 30, 0, 0, 7, 18, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 22, 0, 0, 1, 9, 0, 0, 1, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 11, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewvs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewvs.h new file mode 100644 index 0000000000..ba1c5425e2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11multiviewvs.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_VertexID 0 x 0 VERTID uint x +// SV_InstanceID 0 x 1 INSTID uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// TEXCOORD 0 x 1 NONE uint x +// +vs_4_0 +dcl_immediateConstantBuffer { { -1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0}, + { -1.000000, -1.000000, 0, 0}, + { -1.000000, 1.000000, 0, 0}, + { 1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0} } +dcl_input_sgv v0.x, vertex_id +dcl_input_sgv v1.x, instance_id +dcl_output_siv o0.xyzw, position +dcl_output o1.x +dcl_temps 1 +mov r0.x, v0.x +mov o0.xy, icb[r0.x + 0].xyxx +mov o0.zw, l(0,0,0,1.000000) +mov o1.x, v1.x +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_VS_Multiview_Clear[] = { + 68, 88, 66, 67, 29, 63, 249, 196, 208, 130, 142, 190, 155, 101, 165, 213, 91, 14, 122, + 2, 1, 0, 0, 0, 208, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 220, 0, 0, 0, 52, 1, 0, 0, 84, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 84, + 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, + 0, 0, 83, 86, 95, 86, 101, 114, 116, 101, 120, 73, 68, 0, 83, 86, 95, 73, 110, + 115, 116, 97, 110, 99, 101, 73, 68, 0, 171, 171, 79, 83, 71, 78, 80, 0, 0, 0, + 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 14, 0, 0, 83, + 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, + 0, 171, 171, 171, 83, 72, 68, 82, 24, 1, 0, 0, 64, 0, 1, 0, 70, 0, 0, + 0, 53, 24, 0, 0, 26, 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 128, 191, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, + 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 4, 18, 16, 16, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 96, 0, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 101, 0, 0, 3, 18, 32, 16, 0, 1, 0, 0, 0, 104, 0, 0, 2, 1, 0, + 0, 0, 54, 0, 0, 5, 18, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 50, 32, 16, 0, 0, 0, 0, 0, 70, 144, 144, 0, + 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, + 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 128, 63, 54, 0, 0, 5, 18, 32, 16, 0, 1, 0, 0, 0, 10, 16, 16, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, + 1, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11vs.h new file mode 100644 index 0000000000..035a1fdca0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clear11vs.h @@ -0,0 +1,69 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_VertexID 0 x 0 VERTID uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// +vs_4_0 +dcl_immediateConstantBuffer { { -1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0}, + { -1.000000, -1.000000, 0, 0}, + { -1.000000, 1.000000, 0, 0}, + { 1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0} } +dcl_input_sgv v0.x, vertex_id +dcl_output_siv o0.xyzw, position +dcl_temps 1 +mov r0.x, v0.x +mov o0.xy, icb[r0.x + 0].xyxx +mov o0.zw, l(0,0,0,1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_VS_Clear[] = { + 68, 88, 66, 67, 142, 0, 156, 121, 128, 35, 189, 41, 14, 141, 59, 193, 158, 19, 28, + 184, 1, 0, 0, 0, 84, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 180, 0, 0, 0, 232, 0, 0, 0, 216, 1, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, + 86, 101, 114, 116, 101, 120, 73, 68, 0, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, + 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, + 73, 79, 78, 0, 83, 72, 68, 82, 232, 0, 0, 0, 64, 0, 1, 0, 58, 0, 0, + 0, 53, 24, 0, 0, 26, 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 128, 191, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, + 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 4, 18, 16, 16, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 54, 0, 0, 5, 18, 0, 16, + 0, 0, 0, 0, 0, 10, 16, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 50, 32, + 16, 0, 0, 0, 0, 0, 70, 144, 144, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 6, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/cleardepth11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/cleardepth11ps.h new file mode 100644 index 0000000000..41a39aead9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/cleardepth11ps.h @@ -0,0 +1,74 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer DepthOnlyData +// { +// +// float zValue_Depth; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// DepthOnlyData cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output oDepth +mov oDepth, cb0[1].x +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_ClearDepth[] = { + 68, 88, 66, 67, 27, 164, 102, 59, 78, 154, 233, 127, 65, 17, 101, 9, 4, 119, 201, + 97, 1, 0, 0, 0, 36, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 0, 1, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 168, 1, 0, 0, 82, 68, 69, 70, 196, + 0, 0, 0, 1, 0, 0, 0, 76, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 156, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 68, 101, 112, 116, 104, 79, 110, 108, 121, 68, 97, 116, 97, + 0, 171, 171, 60, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, + 0, 2, 0, 0, 0, 140, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, 108, 117, 101, + 95, 68, 101, 112, 116, 104, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, + 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, + 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, 0, 1, 0, + 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, + 73, 79, 78, 0, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, + 255, 255, 1, 14, 0, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 171, 171, 83, + 72, 68, 82, 56, 0, 0, 0, 64, 0, 0, 0, 14, 0, 0, 0, 89, 0, 0, 4, + 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, + 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11_fl9ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11_fl9ps.h new file mode 100644 index 0000000000..cebc263110 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11_fl9ps.h @@ -0,0 +1,128 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +// +// Constant buffer to DX9 shader constant mappings: +// +// Target Reg Buffer Start Reg # of Regs Data Conversion +// ---------- ------- --------- --------- ---------------------- +// c0 cb0 0 2 ( FLT, FLT, FLT, FLT) +// +// +// Level9 shader bytecode: +// + ps_2_x + mov oC0, c0 + mov oC1, c0 + mov oC2, c0 + mov oC3, c0 + mov oDepth, c1.x + +// approximately 5 instruction slots used +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_ClearFloat_FL9[] = { + 68, 88, 66, 67, 85, 216, 43, 21, 188, 93, 222, 90, 179, 114, 11, 205, 194, 17, 203, + 168, 1, 0, 0, 0, 216, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 180, 0, + 0, 0, 132, 1, 0, 0, 0, 2, 0, 0, 8, 3, 0, 0, 60, 3, 0, 0, 65, + 111, 110, 57, 116, 0, 0, 0, 116, 0, 0, 0, 0, 2, 255, 255, 68, 0, 0, 0, + 48, 0, 0, 0, 1, 0, 36, 0, 0, 0, 48, 0, 0, 0, 48, 0, 0, 0, 36, + 0, 0, 0, 48, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 2, + 255, 255, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 160, 1, 0, 0, 2, 1, + 8, 15, 128, 0, 0, 228, 160, 1, 0, 0, 2, 2, 8, 15, 128, 0, 0, 228, 160, + 1, 0, 0, 2, 3, 8, 15, 128, 0, 0, 228, 160, 1, 0, 0, 2, 0, 8, 15, + 144, 1, 0, 0, 160, 255, 255, 0, 0, 83, 72, 68, 82, 200, 0, 0, 0, 64, 0, + 0, 0, 50, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 2, 1, 192, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, + 68, 69, 70, 0, 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, + 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, + 101, 112, 116, 104, 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, + 2, 0, 0, 0, 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 156, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, + 0, 0, 0, 0, 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, + 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, + 111, 97, 116, 0, 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 122, 86, 97, 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, + 3, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, + 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, + 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, + 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, + 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 148, 0, 0, 0, + 5, 0, 0, 0, 8, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 128, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 15, 0, 0, 0, 128, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 3, 0, 0, 0, 15, 0, 0, 0, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps1.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps1.h new file mode 100644 index 0000000000..d2845b994b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps1.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_ClearFloat1[] = { + 68, 88, 66, 67, 249, 37, 129, 249, 125, 252, 189, 145, 109, 207, 171, 136, 14, 159, 102, + 81, 1, 0, 0, 0, 164, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 196, 1, 0, 0, 40, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 76, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, + 92, 0, 0, 0, 64, 0, 0, 0, 23, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps2.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps2.h new file mode 100644 index 0000000000..b1b3a4e441 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps2.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_ClearFloat2[] = { + 68, 88, 66, 67, 47, 142, 59, 204, 239, 80, 8, 161, 169, 171, 199, 199, 129, 33, 42, + 115, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 220, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 100, 0, 0, 0, 3, 0, 0, 0, + 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 80, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 90, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, + 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, + 171, 83, 72, 68, 82, 128, 0, 0, 0, 64, 0, 0, 0, 32, 0, 0, 0, 89, 0, + 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, + 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps3.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps3.h new file mode 100644 index 0000000000..e84854ff68 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps3.h @@ -0,0 +1,97 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_ClearFloat3[] = { + 68, 88, 66, 67, 98, 17, 13, 150, 202, 50, 172, 72, 101, 93, 116, 134, 154, 66, 233, + 63, 1, 0, 0, 0, 28, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 244, 1, 0, 0, 160, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 124, 0, 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, + 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, + 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 164, 0, 0, 0, 64, 0, 0, 0, 41, + 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, + 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, + 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps4.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps4.h new file mode 100644 index 0000000000..60584aceef --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps4.h @@ -0,0 +1,104 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_ClearFloat4[] = { + 68, 88, 66, 67, 138, 36, 21, 91, 225, 8, 214, 250, 89, 152, 40, 168, 243, 126, 8, + 187, 1, 0, 0, 0, 88, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 12, 2, 0, 0, 220, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 148, 0, 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, + 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 200, 0, 0, 0, + 64, 0, 0, 0, 50, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 2, + 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, + 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps5.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps5.h new file mode 100644 index 0000000000..15c0545fee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps5.h @@ -0,0 +1,110 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_TARGET 4 xyzw 4 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_ClearFloat5[] = { + 68, 88, 66, 67, 19, 82, 125, 81, 104, 222, 105, 50, 128, 46, 184, 118, 230, 154, 80, + 52, 1, 0, 0, 0, 148, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 36, 2, 0, 0, 24, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 172, 0, 0, 0, 6, 0, 0, 0, + 8, 0, 0, 0, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 152, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, + 82, 236, 0, 0, 0, 64, 0, 0, 0, 59, 0, 0, 0, 89, 0, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 2, 1, 192, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps6.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps6.h new file mode 100644 index 0000000000..7cd6a03188 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps6.h @@ -0,0 +1,116 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_TARGET 4 xyzw 4 TARGET float xyzw +// SV_TARGET 5 xyzw 5 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_ClearFloat6[] = { + 68, 88, 66, 67, 115, 157, 164, 56, 254, 153, 37, 126, 220, 182, 131, 196, 87, 71, 44, + 30, 1, 0, 0, 0, 208, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 60, 2, 0, 0, 84, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 196, 0, 0, 0, 7, 0, 0, 0, + 8, 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 176, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 176, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 186, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, + 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, + 0, 171, 83, 72, 68, 82, 16, 1, 0, 0, 64, 0, 0, 0, 68, 0, 0, 0, 89, + 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, + 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps7.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps7.h new file mode 100644 index 0000000000..048471ad6b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps7.h @@ -0,0 +1,122 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_TARGET 4 xyzw 4 TARGET float xyzw +// SV_TARGET 5 xyzw 5 TARGET float xyzw +// SV_TARGET 6 xyzw 6 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_ClearFloat7[] = { + 68, 88, 66, 67, 142, 12, 138, 6, 10, 107, 58, 43, 178, 14, 208, 224, 48, 233, 91, + 50, 1, 0, 0, 0, 12, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 84, 2, 0, 0, 144, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 220, 0, 0, 0, 8, 0, 0, 0, + 8, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 200, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, + 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, + 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 52, 1, 0, 0, 64, 0, 0, 0, + 77, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, + 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps8.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps8.h new file mode 100644 index 0000000000..b338868e18 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearfloat11ps8.h @@ -0,0 +1,128 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataFloat +// { +// +// float4 color_Float; // Offset: 0 Size: 16 +// float zValueF_Float; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataFloat cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// SV_TARGET 1 xyzw 1 TARGET float xyzw +// SV_TARGET 2 xyzw 2 TARGET float xyzw +// SV_TARGET 3 xyzw 3 TARGET float xyzw +// SV_TARGET 4 xyzw 4 TARGET float xyzw +// SV_TARGET 5 xyzw 5 TARGET float xyzw +// SV_TARGET 6 xyzw 6 TARGET float xyzw +// SV_TARGET 7 xyzw 7 TARGET float xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output o7.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov o7.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_ClearFloat8[] = { + 68, 88, 66, 67, 228, 232, 153, 58, 173, 161, 124, 75, 45, 184, 173, 123, 62, 150, 36, + 145, 1, 0, 0, 0, 72, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 108, 2, 0, 0, 204, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 70, 108, 111, 97, 116, 0, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 70, 108, 111, 97, 116, 0, + 1, 0, 3, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 70, 108, 111, 97, 116, 0, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 244, 0, 0, 0, 9, 0, 0, 0, + 8, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 224, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 224, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 7, 0, + 0, 0, 15, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, + 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 88, 1, 0, + 0, 64, 0, 0, 0, 86, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 7, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 7, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps1.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps1.h new file mode 100644 index 0000000000..d6139430ee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps1.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_ClearSint1[] = { + 68, 88, 66, 67, 231, 188, 2, 59, 91, 73, 220, 119, 245, 143, 245, 143, 240, 202, 170, + 163, 1, 0, 0, 0, 164, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 196, 1, 0, 0, 40, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 76, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, + 92, 0, 0, 0, 64, 0, 0, 0, 23, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps2.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps2.h new file mode 100644 index 0000000000..a7cc7221ce --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps2.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_ClearSint2[] = { + 68, 88, 66, 67, 85, 225, 210, 35, 166, 97, 84, 193, 114, 210, 51, 82, 238, 19, 251, + 198, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 220, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 100, 0, 0, 0, 3, 0, 0, 0, + 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 80, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 90, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, + 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, + 171, 83, 72, 68, 82, 128, 0, 0, 0, 64, 0, 0, 0, 32, 0, 0, 0, 89, 0, + 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, + 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps3.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps3.h new file mode 100644 index 0000000000..053de6d738 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps3.h @@ -0,0 +1,97 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_ClearSint3[] = { + 68, 88, 66, 67, 101, 236, 110, 148, 64, 148, 5, 108, 246, 70, 148, 1, 36, 90, 92, + 9, 1, 0, 0, 0, 28, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 244, 1, 0, 0, 160, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 124, 0, 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, + 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, + 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 164, 0, 0, 0, 64, 0, 0, 0, 41, + 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, + 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, + 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps4.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps4.h new file mode 100644 index 0000000000..134f6253ee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps4.h @@ -0,0 +1,104 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_TARGET 3 xyzw 3 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_ClearSint4[] = { + 68, 88, 66, 67, 206, 59, 157, 191, 139, 37, 109, 85, 193, 141, 185, 200, 81, 149, 0, + 246, 1, 0, 0, 0, 88, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 12, 2, 0, 0, 220, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 148, 0, 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, + 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 200, 0, 0, 0, + 64, 0, 0, 0, 50, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 2, + 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, + 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps5.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps5.h new file mode 100644 index 0000000000..3466e72460 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps5.h @@ -0,0 +1,110 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_TARGET 3 xyzw 3 TARGET int xyzw +// SV_TARGET 4 xyzw 4 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_ClearSint5[] = { + 68, 88, 66, 67, 91, 91, 66, 76, 160, 92, 0, 147, 5, 30, 128, 248, 1, 125, 140, + 124, 1, 0, 0, 0, 148, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 36, 2, 0, 0, 24, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 172, 0, 0, 0, 6, 0, 0, 0, + 8, 0, 0, 0, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 152, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, + 82, 236, 0, 0, 0, 64, 0, 0, 0, 59, 0, 0, 0, 89, 0, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 2, 1, 192, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps6.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps6.h new file mode 100644 index 0000000000..b54bcf1fea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps6.h @@ -0,0 +1,116 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_TARGET 3 xyzw 3 TARGET int xyzw +// SV_TARGET 4 xyzw 4 TARGET int xyzw +// SV_TARGET 5 xyzw 5 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_ClearSint6[] = { + 68, 88, 66, 67, 245, 94, 2, 129, 134, 247, 241, 8, 253, 220, 200, 172, 215, 17, 127, + 35, 1, 0, 0, 0, 208, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 60, 2, 0, 0, 84, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 196, 0, 0, 0, 7, 0, 0, 0, + 8, 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 176, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 176, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 186, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, + 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, + 0, 171, 83, 72, 68, 82, 16, 1, 0, 0, 64, 0, 0, 0, 68, 0, 0, 0, 89, + 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, + 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps7.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps7.h new file mode 100644 index 0000000000..0c7755d295 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps7.h @@ -0,0 +1,122 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_TARGET 3 xyzw 3 TARGET int xyzw +// SV_TARGET 4 xyzw 4 TARGET int xyzw +// SV_TARGET 5 xyzw 5 TARGET int xyzw +// SV_TARGET 6 xyzw 6 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_ClearSint7[] = { + 68, 88, 66, 67, 203, 48, 20, 196, 108, 146, 109, 165, 143, 63, 145, 150, 29, 34, 214, + 22, 1, 0, 0, 0, 12, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 84, 2, 0, 0, 144, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 220, 0, 0, 0, 8, 0, 0, 0, + 8, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 200, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, + 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, + 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 52, 1, 0, 0, 64, 0, 0, 0, + 77, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, + 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps8.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps8.h new file mode 100644 index 0000000000..10e77dfcc3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearsint11ps8.h @@ -0,0 +1,128 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataSint +// { +// +// int4 color_Sint; // Offset: 0 Size: 16 +// float zValueF_Sint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataSint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// SV_TARGET 1 xyzw 1 TARGET int xyzw +// SV_TARGET 2 xyzw 2 TARGET int xyzw +// SV_TARGET 3 xyzw 3 TARGET int xyzw +// SV_TARGET 4 xyzw 4 TARGET int xyzw +// SV_TARGET 5 xyzw 5 TARGET int xyzw +// SV_TARGET 6 xyzw 6 TARGET int xyzw +// SV_TARGET 7 xyzw 7 TARGET int xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output o7.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov o7.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_ClearSint8[] = { + 68, 88, 66, 67, 199, 7, 207, 179, 143, 119, 139, 38, 92, 223, 215, 110, 33, 171, 222, + 186, 1, 0, 0, 0, 72, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 108, 2, 0, 0, 204, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 83, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 83, 105, 110, 116, 0, 171, + 1, 0, 2, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 83, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 244, 0, 0, 0, 9, 0, 0, 0, + 8, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 224, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 224, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 7, 0, + 0, 0, 15, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, + 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 88, 1, 0, + 0, 64, 0, 0, 0, 86, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 7, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 7, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps1.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps1.h new file mode 100644 index 0000000000..10f1a56e51 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps1.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_ClearUint1[] = { + 68, 88, 66, 67, 153, 3, 197, 234, 233, 241, 61, 147, 138, 167, 150, 193, 156, 181, 197, + 213, 1, 0, 0, 0, 164, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 196, 1, 0, 0, 40, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 76, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, + 92, 0, 0, 0, 64, 0, 0, 0, 23, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps2.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps2.h new file mode 100644 index 0000000000..8c94b388f9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps2.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_ClearUint2[] = { + 68, 88, 66, 67, 192, 246, 30, 248, 11, 186, 26, 252, 71, 98, 86, 143, 152, 241, 57, + 66, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 220, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 100, 0, 0, 0, 3, 0, 0, 0, + 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 80, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 90, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, + 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, + 171, 83, 72, 68, 82, 128, 0, 0, 0, 64, 0, 0, 0, 32, 0, 0, 0, 89, 0, + 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, + 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps3.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps3.h new file mode 100644 index 0000000000..3c31a85656 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps3.h @@ -0,0 +1,97 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_ClearUint3[] = { + 68, 88, 66, 67, 122, 152, 146, 15, 20, 60, 207, 219, 181, 233, 35, 208, 96, 171, 60, + 29, 1, 0, 0, 0, 28, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 244, 1, 0, 0, 160, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 124, 0, 0, 0, 4, 0, 0, 0, + 8, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 104, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, + 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, + 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 164, 0, 0, 0, 64, 0, 0, 0, 41, + 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, + 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, + 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps4.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps4.h new file mode 100644 index 0000000000..722f1f0acc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps4.h @@ -0,0 +1,104 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_TARGET 3 xyzw 3 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_ClearUint4[] = { + 68, 88, 66, 67, 255, 94, 158, 125, 94, 174, 68, 246, 120, 231, 8, 70, 114, 202, 111, + 31, 1, 0, 0, 0, 88, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 12, 2, 0, 0, 220, 2, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 148, 0, 0, 0, 5, 0, 0, 0, + 8, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 128, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 128, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, + 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 200, 0, 0, 0, + 64, 0, 0, 0, 50, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 2, + 1, 192, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, + 32, 16, 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps5.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps5.h new file mode 100644 index 0000000000..d387a76848 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps5.h @@ -0,0 +1,110 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_TARGET 3 xyzw 3 TARGET uint xyzw +// SV_TARGET 4 xyzw 4 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_ClearUint5[] = { + 68, 88, 66, 67, 208, 22, 91, 140, 204, 34, 72, 161, 50, 27, 2, 156, 220, 29, 44, + 80, 1, 0, 0, 0, 148, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 36, 2, 0, 0, 24, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 172, 0, 0, 0, 6, 0, 0, 0, + 8, 0, 0, 0, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 152, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 152, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 152, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, + 82, 236, 0, 0, 0, 64, 0, 0, 0, 59, 0, 0, 0, 89, 0, 0, 4, 70, 142, + 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, + 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 2, 1, 192, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 2, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps6.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps6.h new file mode 100644 index 0000000000..b3dce8228d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps6.h @@ -0,0 +1,116 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_TARGET 3 xyzw 3 TARGET uint xyzw +// SV_TARGET 4 xyzw 4 TARGET uint xyzw +// SV_TARGET 5 xyzw 5 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_ClearUint6[] = { + 68, 88, 66, 67, 78, 113, 96, 10, 75, 203, 142, 20, 121, 52, 202, 19, 182, 137, 113, + 117, 1, 0, 0, 0, 208, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 60, 2, 0, 0, 84, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 196, 0, 0, 0, 7, 0, 0, 0, + 8, 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 176, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 176, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 176, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 186, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, + 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, + 0, 171, 83, 72, 68, 82, 16, 1, 0, 0, 64, 0, 0, 0, 68, 0, 0, 0, 89, + 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, + 54, 0, 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, + 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, 192, 0, 0, + 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps7.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps7.h new file mode 100644 index 0000000000..95987043f2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps7.h @@ -0,0 +1,122 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_TARGET 3 xyzw 3 TARGET uint xyzw +// SV_TARGET 4 xyzw 4 TARGET uint xyzw +// SV_TARGET 5 xyzw 5 TARGET uint xyzw +// SV_TARGET 6 xyzw 6 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_ClearUint7[] = { + 68, 88, 66, 67, 187, 93, 194, 62, 133, 16, 185, 196, 51, 199, 55, 8, 8, 169, 14, + 118, 1, 0, 0, 0, 12, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 84, 2, 0, 0, 144, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 220, 0, 0, 0, 8, 0, 0, 0, + 8, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 200, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 200, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 200, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, + 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 83, 86, 95, + 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 52, 1, 0, 0, 64, 0, 0, 0, + 77, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 2, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, + 0, 6, 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, + 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, + 16, 0, 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, + 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 1, + 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps8.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps8.h new file mode 100644 index 0000000000..c470ab47bf --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/clearuint11ps8.h @@ -0,0 +1,128 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer ColorAndDepthDataUint +// { +// +// uint4 color_Uint; // Offset: 0 Size: 16 +// float zValueF_Uint; // Offset: 16 Size: 4 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// ColorAndDepthDataUint cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// SV_TARGET 1 xyzw 1 TARGET uint xyzw +// SV_TARGET 2 xyzw 2 TARGET uint xyzw +// SV_TARGET 3 xyzw 3 TARGET uint xyzw +// SV_TARGET 4 xyzw 4 TARGET uint xyzw +// SV_TARGET 5 xyzw 5 TARGET uint xyzw +// SV_TARGET 6 xyzw 6 TARGET uint xyzw +// SV_TARGET 7 xyzw 7 TARGET uint xyzw +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_constantbuffer CB0[2], immediateIndexed +dcl_output o0.xyzw +dcl_output o1.xyzw +dcl_output o2.xyzw +dcl_output o3.xyzw +dcl_output o4.xyzw +dcl_output o5.xyzw +dcl_output o6.xyzw +dcl_output o7.xyzw +dcl_output oDepth +mov o0.xyzw, cb0[0].xyzw +mov o1.xyzw, cb0[0].xyzw +mov o2.xyzw, cb0[0].xyzw +mov o3.xyzw, cb0[0].xyzw +mov o4.xyzw, cb0[0].xyzw +mov o5.xyzw, cb0[0].xyzw +mov o6.xyzw, cb0[0].xyzw +mov o7.xyzw, cb0[0].xyzw +mov oDepth, cb0[1].x +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_ClearUint8[] = { + 68, 88, 66, 67, 206, 106, 135, 121, 179, 175, 105, 51, 32, 41, 211, 246, 201, 25, 75, + 237, 1, 0, 0, 0, 72, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 60, 1, + 0, 0, 112, 1, 0, 0, 108, 2, 0, 0, 204, 3, 0, 0, 82, 68, 69, 70, 0, + 1, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 216, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 67, 111, 108, 111, 114, 65, 110, 100, 68, 101, 112, 116, 104, + 68, 97, 116, 97, 85, 105, 110, 116, 0, 171, 171, 60, 0, 0, 0, 2, 0, 0, 0, + 108, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 168, 0, 0, 0, 0, 0, + 0, 0, 184, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 99, 111, 108, 111, 114, 95, 85, 105, 110, 116, 0, 171, + 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 86, 97, + 108, 117, 101, 70, 95, 85, 105, 110, 116, 0, 171, 171, 171, 0, 0, 3, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 79, 83, 71, 78, 244, 0, 0, 0, 9, 0, 0, 0, + 8, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 15, 0, 0, 0, + 224, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 15, 0, 0, 0, 224, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 15, 0, 0, 0, 224, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 6, 0, 0, 0, 15, 0, 0, + 0, 224, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 0, + 0, 0, 15, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, + 84, 0, 83, 86, 95, 68, 69, 80, 84, 72, 0, 171, 83, 72, 68, 82, 88, 1, 0, + 0, 64, 0, 0, 0, 86, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 3, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 4, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 5, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 6, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 7, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 54, 0, 0, 6, + 242, 32, 16, 0, 0, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 242, 32, 16, 0, 1, 0, 0, 0, 70, 142, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 2, 0, 0, 0, 70, + 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, + 3, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 242, 32, 16, 0, 4, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 5, 0, 0, 0, 70, 142, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, 0, 6, 0, 0, 0, + 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 242, 32, 16, + 0, 7, 0, 0, 0, 70, 142, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 1, 192, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2d_ps.h new file mode 100644 index 0000000000..215c315abf --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2d_ps.h @@ -0,0 +1,76 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMA_2D[] = { + 68, 88, 66, 67, 196, 88, 192, 127, 243, 30, 81, 182, 148, 19, 99, 57, 115, 181, 138, + 146, 1, 0, 0, 0, 128, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 4, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, + 0, 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2darray_ps.h new file mode 100644 index 0000000000..6918bb1bb3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_2darray_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMA_2DArray[] = { + 68, 88, 66, 67, 96, 91, 207, 234, 31, 106, 235, 231, 220, 198, 196, 200, 17, 9, 209, + 197, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 212, 0, 0, 0, 64, 0, + 0, 0, 53, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_3d_ps.h new file mode 100644 index 0000000000..0c5f9d3b26 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMA_3D[] = { + 68, 88, 66, 67, 241, 186, 22, 7, 74, 156, 103, 227, 226, 7, 140, 127, 65, 83, 2, + 111, 1, 0, 0, 0, 176, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 52, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, 0, 0, 39, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2d_ps.h new file mode 100644 index 0000000000..5904f217e3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2d_ps.h @@ -0,0 +1,76 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMAALPHA_2D[] = { + 68, 88, 66, 67, 101, 29, 108, 117, 250, 233, 255, 220, 65, 43, 102, 162, 164, 247, 189, + 112, 1, 0, 0, 0, 128, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 4, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, + 0, 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2darray_ps.h new file mode 100644 index 0000000000..09d9bad5c0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_2darray_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMAALPHA_2DArray[] = { + 68, 88, 66, 67, 16, 148, 215, 158, 112, 164, 42, 84, 33, 70, 148, 190, 238, 94, 245, + 128, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 212, 0, 0, 0, 64, 0, + 0, 0, 53, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_3d_ps.h new file mode 100644 index 0000000000..d8ca1c845a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xxxx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_LUMAALPHA_3D[] = { + 68, 88, 66, 67, 9, 39, 6, 28, 108, 109, 23, 108, 237, 131, 58, 1, 102, 159, 191, + 61, 1, 0, 0, 0, 176, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 52, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, 0, 0, 39, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2d_ps.h new file mode 100644 index 0000000000..be18a987f8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2d_ps.h @@ -0,0 +1,76 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_2D[] = { + 68, 88, 66, 67, 87, 204, 158, 94, 75, 152, 102, 217, 0, 88, 222, 29, 232, 182, 2, + 132, 1, 0, 0, 0, 128, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 4, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, + 0, 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2darray_ps.h new file mode 100644 index 0000000000..7f18036816 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_2darray_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_2DArray[] = { + 68, 88, 66, 67, 73, 224, 127, 95, 171, 173, 116, 230, 242, 111, 205, 239, 210, 69, 91, + 238, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 212, 0, 0, 0, 64, 0, + 0, 0, 53, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_3d_ps.h new file mode 100644 index 0000000000..78ed86a6cf --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_3D[] = { + 68, 88, 66, 67, 188, 235, 5, 90, 236, 180, 172, 101, 155, 220, 117, 214, 110, 8, 67, + 121, 1, 0, 0, 0, 176, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 52, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, 0, 0, 39, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2d_ps.h new file mode 100644 index 0000000000..05af034cf3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2d_ps.h @@ -0,0 +1,84 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_565_2D[] = { + 68, 88, 66, 67, 107, 29, 4, 204, 154, 16, 239, 118, 140, 65, 255, 118, 32, 171, 247, + 239, 1, 0, 0, 0, 228, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 104, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 0, 1, 0, 0, 64, + 0, 0, 0, 64, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, 0, 0, 0, + 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, 4, 61, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2darray_ps.h new file mode 100644 index 0000000000..af5eb349ba --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_2darray_ps.h @@ -0,0 +1,94 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_565_2DArray[] = { + 68, 88, 66, 67, 45, 176, 85, 221, 234, 218, 205, 113, 163, 153, 221, 15, 166, 157, 230, + 200, 1, 0, 0, 0, 84, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 216, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 56, 1, 0, 0, 64, 0, + 0, 0, 78, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, 0, 0, 0, 64, 0, + 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, 4, 61, 0, 0, 0, + 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_3d_ps.h new file mode 100644 index 0000000000..bf02050d89 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_565_3d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGB_565_3D[] = { + 68, 88, 66, 67, 72, 210, 100, 140, 147, 53, 29, 56, 170, 112, 233, 37, 175, 201, 198, + 250, 1, 0, 0, 0, 20, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 152, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, + 124, 66, 0, 0, 248, 65, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, + 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 32, 16, 0, + 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, + 61, 33, 8, 130, 60, 8, 33, 4, 61, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, + 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2d_ps.h new file mode 100644 index 0000000000..68712ef7f5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2d_ps.h @@ -0,0 +1,76 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_2D[] = { + 68, 88, 66, 67, 132, 105, 208, 138, 186, 182, 112, 82, 173, 16, 240, 222, 116, 72, 178, + 126, 1, 0, 0, 0, 128, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 4, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, + 0, 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2darray_ps.h new file mode 100644 index 0000000000..2f0b59abe0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_2darray_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_2DArray[] = { + 68, 88, 66, 67, 61, 17, 53, 94, 235, 123, 58, 146, 86, 204, 96, 4, 97, 221, 95, + 134, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 212, 0, 0, 0, 64, 0, + 0, 0, 53, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_3d_ps.h new file mode 100644 index 0000000000..62d18d62db --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_3D[] = { + 68, 88, 66, 67, 80, 173, 64, 240, 1, 143, 85, 115, 221, 254, 89, 145, 213, 191, 49, + 141, 1, 0, 0, 0, 176, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 52, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, 0, 0, 39, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2d_ps.h new file mode 100644 index 0000000000..62e59d2e4e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_4444_2D[] = { + 68, 88, 66, 67, 52, 89, 222, 242, 25, 197, 40, 54, 79, 232, 156, 234, 251, 41, 41, + 226, 1, 0, 0, 0, 208, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 84, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 236, 0, 0, 0, 64, + 0, 0, 0, 59, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, + 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 137, + 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2darray_ps.h new file mode 100644 index 0000000000..ebfce59f6a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_2darray_ps.h @@ -0,0 +1,92 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_4444_2DArray[] = { + 68, 88, 66, 67, 119, 1, 180, 34, 213, 167, 228, 86, 205, 242, 230, 17, 87, 32, 74, + 6, 1, 0, 0, 0, 64, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 196, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 36, 1, 0, 0, 64, 0, + 0, 0, 73, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, + 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_3d_ps.h new file mode 100644 index 0000000000..a5dd42a2a7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_4444_3d_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_4444_3D[] = { + 68, 88, 66, 67, 233, 160, 206, 221, 201, 110, 121, 251, 163, 213, 234, 30, 171, 187, 79, + 242, 1, 0, 0, 0, 0, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 132, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 236, 0, 0, 0, 64, 0, 0, 0, 59, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 112, 65, 0, 0, + 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 64, 0, 0, 5, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, + 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 137, 136, 136, + 61, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2d_ps.h new file mode 100644 index 0000000000..fca424ebc2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_5551_2D[] = { + 68, 88, 66, 67, 157, 187, 40, 209, 230, 225, 190, 246, 40, 140, 167, 190, 61, 115, 94, + 70, 1, 0, 0, 0, 208, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 84, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 236, 0, 0, 0, 64, + 0, 0, 0, 59, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 128, 63, + 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, 8, 33, 4, 61, 0, + 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2darray_ps.h new file mode 100644 index 0000000000..ee5c7d6e27 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_2darray_ps.h @@ -0,0 +1,92 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_5551_2DArray[] = { + 68, 88, 66, 67, 66, 21, 128, 163, 11, 21, 65, 137, 107, 224, 148, 78, 244, 169, 148, + 247, 1, 0, 0, 0, 64, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 196, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 36, 1, 0, 0, 64, 0, + 0, 0, 73, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 128, 63, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, 8, 33, 4, 61, 0, 0, 128, + 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_3d_ps.h new file mode 100644 index 0000000000..f4b47c002f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_5551_3d_ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_PM_RGBA_5551_3D[] = { + 68, 88, 66, 67, 74, 0, 199, 89, 200, 147, 93, 64, 244, 239, 156, 102, 110, 132, 22, + 10, 1, 0, 0, 0, 0, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 132, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 236, 0, 0, 0, 64, 0, 0, 0, 59, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, + 248, 65, 0, 0, 248, 65, 0, 0, 128, 63, 64, 0, 0, 5, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, + 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, + 61, 8, 33, 4, 61, 8, 33, 4, 61, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2d_ps.h new file mode 100644 index 0000000000..a0023c0013 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r0.w, r0.x, r0.w +movc o0.xyz, r1.xxxx, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMA_2D[] = { + 68, 88, 66, 67, 75, 92, 229, 222, 23, 169, 5, 92, 146, 12, 107, 229, 137, 155, 179, + 250, 1, 0, 0, 0, 192, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 68, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, + 0, 0, 0, 55, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 130, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, + 0, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2darray_ps.h new file mode 100644 index 0000000000..4ad691bef4 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_2darray_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r0.w, r0.x, r0.w +movc o0.xyz, r1.xxxx, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMA_2DArray[] = { + 68, 88, 66, 67, 2, 234, 137, 29, 211, 208, 186, 172, 235, 8, 55, 155, 195, 91, 134, + 133, 1, 0, 0, 0, 48, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 180, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 20, 1, 0, 0, 64, 0, + 0, 0, 69, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 130, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, 0, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_3d_ps.h new file mode 100644 index 0000000000..4eed8c15ba --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r0.w, r0.x, r0.w +movc o0.xyz, r1.xxxx, r0.wwww, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMA_3D[] = { + 68, 88, 66, 67, 120, 214, 14, 47, 69, 88, 46, 178, 8, 214, 190, 124, 42, 131, 170, + 151, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 130, 0, 16, 0, 0, 0, 0, + 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2d_ps.h new file mode 100644 index 0000000000..7501fae643 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.y, r0.x, r0.w +movc o0.xyz, r1.xxxx, r1.yyyy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMAALPHA_2D[] = { + 68, 88, 66, 67, 190, 69, 123, 211, 19, 130, 132, 1, 132, 116, 62, 1, 233, 115, 38, + 22, 1, 0, 0, 0, 192, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 68, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, + 0, 0, 0, 55, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 34, 0, 16, 0, 1, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, + 0, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 86, 5, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2darray_ps.h new file mode 100644 index 0000000000..40eb1f480c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_2darray_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.y, r0.x, r0.w +movc o0.xyz, r1.xxxx, r1.yyyy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMAALPHA_2DArray[] = { + 68, 88, 66, 67, 222, 131, 31, 168, 174, 145, 73, 243, 164, 132, 216, 2, 103, 0, 142, + 101, 1, 0, 0, 0, 48, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 180, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 20, 1, 0, 0, 64, 0, + 0, 0, 69, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 34, 0, 16, 0, 1, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, 0, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 86, 5, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_3d_ps.h new file mode 100644 index 0000000000..f6bbc8cc01 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.y, r0.x, r0.w +movc o0.xyz, r1.xxxx, r1.yyyy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_LUMAALPHA_3D[] = { + 68, 88, 66, 67, 160, 196, 1, 185, 15, 156, 153, 67, 85, 102, 198, 128, 138, 216, 238, + 143, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 34, 0, 16, 0, 1, 0, 0, + 0, 10, 0, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 86, + 5, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2d_ps.h new file mode 100644 index 0000000000..ce44a394d7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_2D[] = { + 68, 88, 66, 67, 93, 55, 14, 204, 55, 114, 238, 111, 6, 213, 4, 64, 58, 99, 168, + 104, 1, 0, 0, 0, 192, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 68, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, + 0, 0, 0, 55, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2darray_ps.h new file mode 100644 index 0000000000..ea38e2e559 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_2darray_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_2DArray[] = { + 68, 88, 66, 67, 224, 13, 199, 125, 145, 168, 88, 56, 242, 2, 144, 118, 87, 186, 241, + 248, 1, 0, 0, 0, 48, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 180, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 20, 1, 0, 0, 64, 0, + 0, 0, 69, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_3d_ps.h new file mode 100644 index 0000000000..da862eb119 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_3D[] = { + 68, 88, 66, 67, 200, 37, 175, 150, 106, 41, 102, 69, 21, 246, 40, 148, 142, 99, 101, + 71, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2d_ps.h new file mode 100644 index 0000000000..5996ba335e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2d_ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_565_2D[] = { + 68, 88, 66, 67, 120, 138, 72, 172, 147, 159, 222, 80, 129, 231, 133, 236, 125, 211, 201, + 82, 1, 0, 0, 0, 36, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 168, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 64, 1, 0, 0, 64, + 0, 0, 0, 80, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, + 0, 248, 65, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, + 130, 60, 8, 33, 4, 61, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, + 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 9, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2darray_ps.h new file mode 100644 index 0000000000..b36c06adb0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_2darray_ps.h @@ -0,0 +1,100 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 11 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_565_2DArray[] = { + 68, 88, 66, 67, 44, 2, 174, 208, 118, 237, 233, 207, 57, 29, 178, 223, 138, 140, 88, + 102, 1, 0, 0, 0, 148, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 24, 3, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 120, 1, 0, 0, 64, 0, + 0, 0, 94, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, + 65, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, + 8, 33, 4, 61, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 11, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_3d_ps.h new file mode 100644 index 0000000000..8de8d85d37 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_565_3d_ps.h @@ -0,0 +1,93 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGB_565_3D[] = { + 68, 88, 66, 67, 250, 168, 68, 191, 15, 51, 156, 108, 63, 18, 251, 133, 207, 174, 26, + 44, 1, 0, 0, 0, 84, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 216, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 64, 1, 0, 0, 64, 0, 0, 0, 80, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, 0, 0, 0, 64, 0, + 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, 4, 61, 0, 0, 0, + 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2d_ps.h new file mode 100644 index 0000000000..764b560d78 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2d_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_2D[] = { + 68, 88, 66, 67, 43, 116, 27, 96, 239, 39, 33, 81, 44, 127, 180, 166, 1, 156, 105, + 167, 1, 0, 0, 0, 192, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 68, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, + 0, 0, 0, 55, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, + 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2darray_ps.h new file mode 100644 index 0000000000..84cf6ebefa --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_2darray_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_2DArray[] = { + 68, 88, 66, 67, 226, 210, 183, 205, 237, 244, 131, 11, 158, 229, 134, 100, 181, 52, 86, + 124, 1, 0, 0, 0, 48, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 180, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 20, 1, 0, 0, 64, 0, + 0, 0, 69, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, + 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_3d_ps.h new file mode 100644 index 0000000000..d0725735e4 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_3D[] = { + 68, 88, 66, 67, 47, 35, 68, 46, 230, 212, 160, 221, 21, 19, 140, 22, 115, 9, 100, + 58, 1, 0, 0, 0, 240, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 116, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2d_ps.h new file mode 100644 index 0000000000..cfa23a7bf9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_4444_2D[] = { + 68, 88, 66, 67, 233, 41, 159, 52, 49, 178, 50, 48, 148, 28, 18, 200, 140, 164, 4, + 13, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 44, 1, 0, 0, 64, + 0, 0, 0, 75, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, + 0, 112, 65, 0, 0, 112, 65, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, + 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2darray_ps.h new file mode 100644 index 0000000000..1a08e60147 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_2darray_ps.h @@ -0,0 +1,98 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_4444_2DArray[] = { + 68, 88, 66, 67, 51, 224, 15, 241, 219, 215, 90, 241, 40, 140, 3, 53, 152, 74, 169, + 200, 1, 0, 0, 0, 128, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 4, 3, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 100, 1, 0, 0, 64, 0, + 0, 0, 89, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, + 65, 0, 0, 112, 65, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, + 137, 136, 136, 61, 137, 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 10, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_3d_ps.h new file mode 100644 index 0000000000..ef493e3f4b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_4444_3d_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_4444_3D[] = { + 68, 88, 66, 67, 210, 247, 48, 228, 222, 252, 207, 191, 86, 78, 158, 63, 239, 245, 179, + 7, 1, 0, 0, 0, 64, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 196, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 44, 1, 0, 0, 64, 0, 0, 0, 75, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, + 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2d_ps.h new file mode 100644 index 0000000000..42829c90c9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_5551_2D[] = { + 68, 88, 66, 67, 140, 39, 186, 158, 51, 211, 162, 56, 171, 90, 89, 241, 42, 247, 30, + 222, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 44, 1, 0, 0, 64, + 0, 0, 0, 75, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, + 0, 248, 65, 0, 0, 128, 63, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, + 4, 61, 8, 33, 4, 61, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2darray_ps.h new file mode 100644 index 0000000000..22389cfa5d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_2darray_ps.h @@ -0,0 +1,98 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_5551_2DArray[] = { + 68, 88, 66, 67, 17, 161, 17, 46, 139, 141, 231, 172, 21, 139, 205, 213, 78, 192, 111, + 150, 1, 0, 0, 0, 128, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 4, 3, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 100, 1, 0, 0, 64, 0, + 0, 0, 89, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, + 65, 0, 0, 128, 63, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, + 8, 33, 4, 61, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 10, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_3d_ps.h new file mode 100644 index 0000000000..a97e54f1d2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_5551_3d_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoF_UM_RGBA_5551_3D[] = { + 68, 88, 66, 67, 95, 144, 206, 44, 123, 213, 142, 219, 42, 152, 39, 211, 195, 66, 184, + 29, 1, 0, 0, 0, 64, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 196, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 44, 1, 0, 0, 64, 0, 0, 0, 75, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 128, 63, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, 8, 33, 4, 61, 0, 0, 128, + 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_2darray_ps.h new file mode 100644 index 0000000000..2921c17e7d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_2darray_ps.h @@ -0,0 +1,96 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_FtoI_PM_RGB_2DArray[] = { + 68, 88, 66, 67, 214, 86, 133, 76, 36, 73, 187, 120, 120, 177, 199, 23, 161, 34, 44, + 41, 1, 0, 0, 0, 104, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 236, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 76, 1, 0, 0, 64, 0, + 0, 0, 83, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 0, 0, 64, 0, + 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 0, + 0, 27, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_3d_ps.h new file mode 100644 index 0000000000..18741678e1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgb_3d_ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoI_PM_RGB_3D[] = { + 68, 88, 66, 67, 233, 244, 68, 31, 244, 75, 174, 119, 157, 230, 155, 216, 124, 72, 238, + 41, 1, 0, 0, 0, 40, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 172, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 20, 1, 0, 0, 64, 0, 0, 0, 69, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, + 254, 66, 0, 0, 254, 66, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, + 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, + 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, + 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 0, 0, 27, 0, 0, 5, 114, 32, + 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, + 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_2darray_ps.h new file mode 100644 index 0000000000..f877df2d74 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_2darray_ps.h @@ -0,0 +1,94 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoI_PM_RGBA_2DArray[] = { + 68, 88, 66, 67, 6, 46, 120, 27, 94, 101, 87, 132, 53, 181, 154, 63, 109, 237, 51, + 143, 1, 0, 0, 0, 84, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 216, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 56, 1, 0, 0, 64, 0, + 0, 0, 78, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, + 63, 27, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_3d_ps.h new file mode 100644 index 0000000000..e4b96a279b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pm_rgba_3d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoI_PM_RGBA_3D[] = { + 68, 88, 66, 67, 249, 90, 79, 118, 112, 44, 159, 0, 189, 165, 140, 198, 201, 78, 213, + 100, 1, 0, 0, 0, 20, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 152, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, + 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 64, 0, 0, 5, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, + 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, + 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 27, 0, 0, 5, 242, 32, + 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_2darray_ps.h new file mode 100644 index 0000000000..8970316b3d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_2darray_ps.h @@ -0,0 +1,94 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoI_PT_RGB_2DArray[] = { + 68, 88, 66, 67, 168, 185, 143, 219, 147, 147, 203, 58, 217, 196, 122, 65, 228, 189, 209, + 238, 1, 0, 0, 0, 76, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 208, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 48, 1, 0, 0, 64, 0, + 0, 0, 76, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, + 0, 0, 254, 66, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, + 0, 128, 63, 0, 0, 128, 63, 0, 0, 0, 0, 27, 0, 0, 5, 114, 32, 16, 0, + 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, + 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_3d_ps.h new file mode 100644 index 0000000000..3f93541ea7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgb_3d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoI_PT_RGB_3D[] = { + 68, 88, 66, 67, 65, 66, 171, 227, 204, 106, 7, 188, 141, 169, 26, 209, 77, 251, 140, + 247, 1, 0, 0, 0, 12, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 144, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 248, 0, 0, 0, 64, 0, 0, 0, 62, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 0, + 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, + 0, 0, 0, 0, 27, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_2darray_ps.h new file mode 100644 index 0000000000..493fc2292b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_2darray_ps.h @@ -0,0 +1,92 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoI_PT_RGBA_2DArray[] = { + 68, 88, 66, 67, 157, 78, 228, 79, 217, 28, 225, 96, 83, 195, 47, 176, 240, 168, 229, + 128, 1, 0, 0, 0, 56, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 188, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 28, 1, 0, 0, 64, 0, + 0, 0, 71, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, + 0, 0, 254, 66, 0, 0, 254, 66, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, + 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 27, 0, 0, 5, 242, 32, 16, 0, + 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_3d_ps.h new file mode 100644 index 0000000000..c602d2fb2e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_pt_rgba_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoI_PT_RGBA_3D[] = { + 68, 88, 66, 67, 73, 236, 106, 44, 249, 119, 115, 91, 94, 156, 145, 139, 146, 47, 33, + 36, 1, 0, 0, 0, 248, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 124, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 228, 0, 0, 0, 64, 0, 0, 0, 57, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, + 66, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, + 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, + 0, 0, 128, 63, 27, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, + 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_2darray_ps.h new file mode 100644 index 0000000000..8335a149c6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_2darray_ps.h @@ -0,0 +1,102 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 12 instruction slots used +#endif + +const BYTE g_PS_FtoI_UM_RGB_2DArray[] = { + 68, 88, 66, 67, 229, 156, 153, 172, 30, 111, 168, 172, 47, 75, 227, 206, 198, 78, 62, + 42, 1, 0, 0, 0, 168, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 44, 3, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 140, 1, 0, 0, 64, 0, + 0, 0, 99, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, + 66, 0, 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, + 0, 0, 128, 63, 0, 0, 0, 0, 27, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_3d_ps.h new file mode 100644 index 0000000000..2df877322f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgb_3d_ps.h @@ -0,0 +1,95 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(127.000000, 127.000000, 127.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, l(1.000000, 1.000000, 1.000000, 0.000000) +ftoi o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_FtoI_UM_RGB_3D[] = { + 68, 88, 66, 67, 23, 5, 101, 80, 190, 217, 192, 233, 141, 228, 109, 126, 239, 211, 129, + 244, 1, 0, 0, 0, 104, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 236, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 84, 1, 0, 0, 64, 0, 0, 0, 85, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 0, 0, 64, 0, + 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 0, + 0, 27, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_2darray_ps.h new file mode 100644 index 0000000000..3d4dfa2bb9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_2darray_ps.h @@ -0,0 +1,100 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 11 instruction slots used +#endif + +const BYTE g_PS_FtoI_UM_RGBA_2DArray[] = { + 68, 88, 66, 67, 131, 143, 223, 155, 139, 202, 127, 87, 193, 203, 100, 239, 91, 19, 167, + 10, 1, 0, 0, 0, 148, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 24, 3, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 120, 1, 0, 0, 64, 0, + 0, 0, 94, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, + 66, 0, 0, 254, 66, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, + 0, 0, 128, 63, 0, 0, 128, 63, 27, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 11, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_3d_ps.h new file mode 100644 index 0000000000..89b06059e3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftoi_um_rgba_3d_ps.h @@ -0,0 +1,93 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(127.000000, 127.000000, 127.000000, 127.000000) +round_ne r0.xyzw, r0.xyzw +mul r0.xyzw, r0.xyzw, l(1.000000, 1.000000, 1.000000, 1.000000) +ftoi o0.xyzw, r0.xyzw +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoI_UM_RGBA_3D[] = { + 68, 88, 66, 67, 221, 247, 207, 180, 133, 35, 246, 152, 57, 87, 23, 116, 186, 51, 233, + 199, 1, 0, 0, 0, 84, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 216, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 64, 1, 0, 0, 64, 0, 0, 0, 80, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 0, 0, 254, 66, 64, 0, + 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 128, + 63, 27, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2d_ps.h new file mode 100644 index 0000000000..29a60b7f93 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2d_ps.h @@ -0,0 +1,81 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGB_2D[] = { + 68, 88, 66, 67, 157, 10, 67, 137, 249, 135, 12, 161, 255, 107, 225, 32, 54, 65, 72, + 121, 1, 0, 0, 0, 188, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 64, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, + 0, 0, 0, 54, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, + 28, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2darray_ps.h new file mode 100644 index 0000000000..f5937d6336 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_2darray_ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGB_2DArray[] = { + 68, 88, 66, 67, 42, 230, 32, 82, 5, 44, 80, 225, 105, 151, 142, 19, 19, 183, 76, + 193, 1, 0, 0, 0, 44, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 176, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 16, 1, 0, 0, 64, 0, + 0, 0, 68, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_3d_ps.h new file mode 100644 index 0000000000..1e074f9236 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_3d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGB_3D[] = { + 68, 88, 66, 67, 181, 194, 196, 252, 71, 44, 79, 110, 172, 188, 24, 27, 37, 220, 16, + 181, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, 0, 0, 0, 54, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, + 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, 0, + 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, + 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2d_ps.h new file mode 100644 index 0000000000..f33e4d5bac --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2d_ps.h @@ -0,0 +1,79 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGBA_2D[] = { + 68, 88, 66, 67, 40, 207, 117, 251, 196, 95, 200, 222, 47, 24, 239, 143, 252, 25, 140, + 25, 1, 0, 0, 0, 168, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 44, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 196, 0, 0, 0, 64, + 0, 0, 0, 49, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, + 0, 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, + 28, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2darray_ps.h new file mode 100644 index 0000000000..42ceb4a597 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_2darray_ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGBA_2DArray[] = { + 68, 88, 66, 67, 72, 177, 176, 126, 150, 61, 34, 127, 37, 128, 200, 148, 82, 84, 84, + 63, 1, 0, 0, 0, 24, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 156, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 252, 0, 0, 0, 64, 0, + 0, 0, 63, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 28, 0, + 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_3d_ps.h new file mode 100644 index 0000000000..1e91151b5a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgba_3d_ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.wwww, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_FtoU_PM_RGBA_3D[] = { + 68, 88, 66, 67, 108, 177, 182, 169, 224, 190, 112, 68, 155, 228, 67, 226, 65, 238, 217, + 116, 1, 0, 0, 0, 216, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 92, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 196, 0, 0, 0, 64, 0, 0, 0, 49, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 114, 0, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, + 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2d_ps.h new file mode 100644 index 0000000000..c74a48f769 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2d_ps.h @@ -0,0 +1,79 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGB_2D[] = { + 68, 88, 66, 67, 21, 43, 226, 215, 164, 244, 10, 22, 123, 34, 48, 235, 95, 92, 229, + 201, 1, 0, 0, 0, 160, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 36, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 188, 0, 0, 0, 64, + 0, 0, 0, 47, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, + 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, 0, + 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, + 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2darray_ps.h new file mode 100644 index 0000000000..dd66bae38b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_2darray_ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGB_2DArray[] = { + 68, 88, 66, 67, 135, 27, 134, 107, 134, 245, 87, 208, 181, 1, 171, 9, 139, 65, 67, + 42, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 244, 0, 0, 0, 64, 0, + 0, 0, 61, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, + 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_3d_ps.h new file mode 100644 index 0000000000..cedb2554e8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgb_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGB_3D[] = { + 68, 88, 66, 67, 198, 108, 113, 77, 139, 67, 45, 18, 83, 139, 168, 237, 165, 209, 182, 76, + 1, 0, 0, 0, 208, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, 0, 0, + 92, 1, 0, 0, 144, 1, 0, 0, 84, 2, 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, + 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, + 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, + 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, 0, 77, 105, 99, 114, 111, 115, 111, 102, + 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, + 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, + 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, + 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, + 83, 72, 68, 82, 188, 0, 0, 0, 64, 0, 0, 0, 47, 0, 0, 0, 90, 0, 0, 3, + 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, + 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, 0, 0, 70, 126, 16, 0, + 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, + 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, + 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, + 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, + 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2d_ps.h new file mode 100644 index 0000000000..22bce837e4 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2d_ps.h @@ -0,0 +1,77 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGBA_2D[] = { + 68, 88, 66, 67, 15, 203, 215, 26, 226, 132, 179, 250, 218, 76, 219, 205, 201, 184, 211, + 22, 1, 0, 0, 0, 140, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 16, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 168, 0, 0, 0, 64, + 0, 0, 0, 42, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, + 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2darray_ps.h new file mode 100644 index 0000000000..3fffb1c2d3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_2darray_ps.h @@ -0,0 +1,87 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGBA_2DArray[] = { + 68, 88, 66, 67, 141, 122, 224, 133, 227, 61, 69, 44, 172, 221, 157, 131, 76, 235, 81, + 130, 1, 0, 0, 0, 252, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 128, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 224, 0, 0, 0, 64, 0, + 0, 0, 56, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, + 0, 0, 127, 67, 0, 0, 127, 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_3d_ps.h new file mode 100644 index 0000000000..bd50542b5d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pt_rgba_3d_ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_FtoU_PT_RGBA_3D[] = { + 68, 88, 66, 67, 60, 29, 156, 198, 163, 110, 141, 222, 219, 229, 175, 1, 103, 9, 217, + 156, 1, 0, 0, 0, 188, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 64, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 168, 0, 0, 0, 64, 0, 0, 0, 42, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, + 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2d_ps.h new file mode 100644 index 0000000000..25149b232d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2d_ps.h @@ -0,0 +1,87 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGB_2D[] = { + 68, 88, 66, 67, 104, 222, 184, 218, 135, 243, 133, 232, 177, 236, 20, 60, 64, 9, 17, + 90, 1, 0, 0, 0, 252, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 128, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 24, 1, 0, 0, 64, + 0, 0, 0, 70, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, + 0, 127, 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, + 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, + 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2darray_ps.h new file mode 100644 index 0000000000..8b8d1d3b7f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_2darray_ps.h @@ -0,0 +1,97 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGB_2DArray[] = { + 68, 88, 66, 67, 211, 11, 247, 147, 13, 61, 188, 52, 49, 20, 122, 213, 216, 130, 203, + 211, 1, 0, 0, 0, 108, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 240, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 80, 1, 0, 0, 64, 0, + 0, 0, 84, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, + 67, 0, 0, 0, 0, 28, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, + 10, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_3d_ps.h new file mode 100644 index 0000000000..f7746e87ee --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgb_3d_ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyz, r0.xyzx, l(255.000000, 255.000000, 255.000000, 0.000000) +ftou o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGB_3D[] = { + 68, 88, 66, 67, 211, 77, 171, 115, 172, 101, 224, 185, 62, 127, 82, 90, 150, 163, 227, + 209, 1, 0, 0, 0, 44, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 176, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 24, 1, 0, 0, 64, 0, 0, 0, 70, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 0, 0, 28, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2d_ps.h new file mode 100644 index 0000000000..71530637ef --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2d_ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGBA_2D[] = { + 68, 88, 66, 67, 79, 47, 172, 229, 63, 231, 120, 201, 52, 133, 90, 84, 23, 233, 153, + 100, 1, 0, 0, 0, 232, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 108, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, + 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 4, 1, 0, 0, 64, + 0, 0, 0, 65, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, + 0, 0, 104, 0, 0, 2, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 0, 96, 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, + 0, 7, 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, + 15, 16, 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, + 6, 0, 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, + 0, 127, 67, 0, 0, 127, 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, + 70, 14, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 7, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2darray_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2darray_ps.h new file mode 100644 index 0000000000..5d75b8df6d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_2darray_ps.h @@ -0,0 +1,95 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_2DArray texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 2 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGBA_2DArray[] = { + 68, 88, 66, 67, 237, 98, 226, 3, 103, 212, 163, 240, 153, 59, 189, 19, 100, 209, 34, + 202, 1, 0, 0, 0, 88, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 220, 0, + 0, 0, 100, 1, 0, 0, 152, 1, 0, 0, 220, 2, 0, 0, 82, 68, 69, 70, 160, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 117, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 50, 68, + 65, 114, 114, 97, 121, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, + 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, + 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, + 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, + 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, + 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 60, 1, 0, 0, 64, 0, + 0, 0, 79, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 64, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, + 18, 16, 16, 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 2, 0, 0, 0, 86, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, + 16, 0, 0, 0, 0, 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, + 226, 0, 16, 0, 1, 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, + 0, 0, 0, 0, 0, 55, 0, 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, + 16, 0, 1, 0, 0, 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, + 67, 0, 0, 127, 67, 28, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_3d_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_3d_ps.h new file mode 100644 index 0000000000..7d98511943 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_um_rgba_3d_ps.h @@ -0,0 +1,88 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF_3D texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc r0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mul r0.xyzw, r0.xyzw, l(255.000000, 255.000000, 255.000000, 255.000000) +ftou o0.xyzw, r0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_FtoU_UM_RGBA_3D[] = { + 68, 88, 66, 67, 9, 246, 142, 132, 23, 145, 144, 223, 33, 247, 146, 14, 116, 28, 69, + 175, 1, 0, 0, 0, 24, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 156, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 112, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 51, 68, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, + 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 4, 1, 0, 0, 64, 0, 0, 0, 65, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 49, + 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, 0, 0, + 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, 55, 0, + 0, 9, 114, 0, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, 0, 150, + 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, + 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 0, 0, 127, 67, 28, 0, + 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h new file mode 100644 index 0000000000..fdeae67ad9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// POSITION 0 xy 0 NONE float xy +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Runtime generated constant mappings: +// +// Target Reg Constant Description +// ---------- -------------------------------------------------- +// c0 Vertex Shader position offset +// +// +// Level9 shader bytecode: +// + vs_2_x + def c1, 0, 1, 0, 0 + dcl_texcoord v0 + dcl_texcoord1 v1 + add oPos.xy, v0, c0 + mov oPos.zw, c1.xyxy + mov oT0.xy, v1 + +// approximately 3 instruction slots used +vs_4_0 +dcl_input v0.xy +dcl_input v1.xy +dcl_output_siv o0.xyzw, position +dcl_output o1.xy +mov o0.xy, v0.xyxx +mov o0.zw, l(0,0,0,1.000000) +mov o1.xy, v1.xyxx +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_VS_Passthrough2D[] = { + 68, 88, 66, 67, 157, 119, 222, 216, 39, 186, 195, 24, 174, 138, 22, 73, 223, 185, 107, + 36, 1, 0, 0, 0, 204, 2, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 200, 0, + 0, 0, 88, 1, 0, 0, 212, 1, 0, 0, 32, 2, 0, 0, 116, 2, 0, 0, 65, + 111, 110, 57, 136, 0, 0, 0, 136, 0, 0, 0, 0, 2, 254, 255, 96, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 36, 0, 0, 0, 36, 0, 0, 0, 36, 0, 0, 0, 36, + 0, 1, 0, 36, 0, 0, 0, 0, 0, 1, 2, 254, 255, 81, 0, 0, 5, 1, 0, + 15, 160, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 5, 0, 0, 128, 0, 0, 15, 144, 31, 0, 0, 2, 5, 0, 1, 128, + 1, 0, 15, 144, 2, 0, 0, 3, 0, 0, 3, 192, 0, 0, 228, 144, 0, 0, 228, + 160, 1, 0, 0, 2, 0, 0, 12, 192, 1, 0, 68, 160, 1, 0, 0, 2, 0, 0, + 3, 224, 1, 0, 228, 144, 255, 255, 0, 0, 83, 72, 68, 82, 136, 0, 0, 0, 64, + 0, 1, 0, 34, 0, 0, 0, 95, 0, 0, 3, 50, 16, 16, 0, 0, 0, 0, 0, + 95, 0, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 101, 0, 0, 3, 50, 32, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 54, 0, 0, + 5, 50, 32, 16, 0, 1, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 4, + 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, + 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, + 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 76, 0, 0, + 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 65, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, + 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 171, 79, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 12, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11gs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11gs.h new file mode 100644 index 0000000000..23fc7f99ea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11gs.h @@ -0,0 +1,93 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// LAYER 0 x 1 NONE uint x +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xyz +// +gs_4_0 +dcl_input_siv v[3][0].xyzw, position +dcl_input v[3][1].x +dcl_input v[3][2].xyz +dcl_temps 1 +dcl_inputprimitive triangle +dcl_outputtopology trianglestrip +dcl_output_siv o0.xyzw, position +dcl_output_siv o1.x, rendertarget_array_index +dcl_output o2.xyz +dcl_maxout 3 +mov r0.x, l(0) +loop + ige r0.y, r0.x, l(3) + breakc_nz r0.y + mov o0.xyzw, v[r0.x + 0][0].xyzw + mov o1.x, v[r0.x + 0][1].x + mov o2.xyz, v[r0.x + 0][2].xyzx + emit + iadd r0.x, r0.x, l(1) +endloop +ret +// Approximately 11 instruction slots used +#endif + +const BYTE g_GS_Passthrough3D[] = { + 68, 88, 66, 67, 226, 188, 145, 36, 193, 19, 254, 1, 249, 51, 174, 53, 33, 65, 233, + 89, 1, 0, 0, 0, 60, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 244, 0, 0, 0, 124, 1, 0, 0, 192, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 83, 71, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 108, + 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 92, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, + 0, 0, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, + 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, + 76, 65, 89, 69, 82, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, + 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 1, 14, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 2, 0, 0, 0, 7, 8, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, + 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, 84, 65, 82, + 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 83, 72, 68, 82, 60, 1, 0, 0, 64, 0, 2, 0, 79, 0, 0, 0, 97, 0, 0, + 5, 242, 16, 32, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 95, 0, + 0, 4, 18, 16, 32, 0, 3, 0, 0, 0, 1, 0, 0, 0, 95, 0, 0, 4, 114, + 16, 32, 0, 3, 0, 0, 0, 2, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, + 93, 24, 0, 1, 92, 40, 0, 1, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 103, 0, 0, 4, 18, 32, 16, 0, 1, 0, 0, 0, 4, 0, + 0, 0, 101, 0, 0, 3, 114, 32, 16, 0, 2, 0, 0, 0, 94, 0, 0, 2, 3, + 0, 0, 0, 54, 0, 0, 5, 18, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 48, 0, 0, 1, 33, 0, 0, 7, 34, 0, 16, 0, 0, 0, 0, + 0, 10, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 3, 0, 0, 0, 3, 0, + 4, 3, 26, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 7, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 30, 160, 0, 10, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 54, 0, 0, 7, 18, 32, 16, 0, 1, 0, 0, 0, 10, 16, 160, 0, 10, 0, 16, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 54, 0, 0, 7, 114, 32, 16, 0, 2, 0, + 0, 0, 70, 18, 160, 0, 10, 0, 16, 0, 0, 0, 0, 0, 2, 0, 0, 0, 19, + 0, 0, 1, 30, 0, 0, 7, 18, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, + 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 22, 0, 0, 1, 62, 0, 0, + 1, 83, 84, 65, 84, 116, 0, 0, 0, 11, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11vs.h new file mode 100644 index 0000000000..3c833f79a8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough3d11vs.h @@ -0,0 +1,75 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// POSITION 0 xy 0 NONE float xy +// LAYER 0 x 1 NONE uint x +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float xyzw +// LAYER 0 x 1 NONE uint x +// TEXCOORD 0 xyz 2 NONE float xyz +// +vs_4_0 +dcl_input v0.xy +dcl_input v1.x +dcl_input v2.xyz +dcl_output_siv o0.xyzw, position +dcl_output o1.x +dcl_output o2.xyz +mov o0.xy, v0.xyxx +mov o0.zw, l(0,0,0,1.000000) +mov o1.x, v1.x +mov o2.xyz, v2.xyzx +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_VS_Passthrough3D[] = { + 68, 88, 66, 67, 136, 150, 103, 162, 167, 195, 182, 112, 150, 17, 18, 65, 73, 164, 12, + 142, 1, 0, 0, 0, 156, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 240, 0, 0, 0, 100, 1, 0, 0, 32, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 104, + 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 89, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, + 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, + 0, 0, 0, 7, 7, 0, 0, 80, 79, 83, 73, 84, 73, 79, 78, 0, 76, 65, 89, + 69, 82, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 79, 83, 71, 78, 108, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 14, 0, 0, + 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, + 0, 7, 8, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 76, 65, + 89, 69, 82, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 83, 72, 68, 82, 180, + 0, 0, 0, 64, 0, 1, 0, 45, 0, 0, 0, 95, 0, 0, 3, 50, 16, 16, 0, + 0, 0, 0, 0, 95, 0, 0, 3, 18, 16, 16, 0, 1, 0, 0, 0, 95, 0, 0, + 3, 114, 16, 16, 0, 2, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 101, 0, 0, 3, 18, 32, 16, 0, 1, 0, 0, 0, 101, + 0, 0, 3, 114, 32, 16, 0, 2, 0, 0, 0, 54, 0, 0, 5, 50, 32, 16, 0, + 0, 0, 0, 0, 70, 16, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 32, 16, + 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 128, 63, 54, 0, 0, 5, 18, 32, 16, 0, 1, 0, 0, 0, 10, + 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, 114, 32, 16, 0, 2, 0, 0, 0, + 70, 18, 16, 0, 2, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrougha2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrougha2d11ps.h new file mode 100644 index 0000000000..a338628659 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrougha2d11ps.h @@ -0,0 +1,103 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 0, 1, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mul r0, r0.w, c0.xxxy + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.w, r0.w +mov o0.xyz, l(0,0,0,0) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughA2D[] = { + 68, 88, 66, 67, 194, 169, 124, 165, 14, 7, 97, 151, 180, 238, 123, 252, 63, 248, 162, + 165, 1, 0, 0, 0, 28, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 204, 0, + 0, 0, 116, 1, 0, 0, 240, 1, 0, 0, 144, 2, 0, 0, 232, 2, 0, 0, 65, + 111, 110, 57, 140, 0, 0, 0, 140, 0, 0, 0, 0, 2, 255, 255, 100, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 5, 0, 0, 3, 0, 0, 15, 128, 0, 0, 255, 128, 0, 0, 64, 160, 1, 0, + 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, 72, 68, 82, 160, + 0, 0, 0, 64, 0, 0, 0, 40, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, + 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, + 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, + 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, + 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 114, 32, + 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, + 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, + 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, + 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, + 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, + 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, + 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, + 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, + 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h new file mode 100644 index 0000000000..e8790cade6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h @@ -0,0 +1,73 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_DEPTH 0 N/A oDepth DEPTH float YES +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output oDepth +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov oDepth, r0.x +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_PassthroughDepth2D[] = { + 68, 88, 66, 67, 215, 216, 149, 20, 177, 67, 115, 222, 9, 179, 226, 21, 58, 197, 172, + 136, 1, 0, 0, 0, 92, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 44, 1, 0, 0, 96, 1, 0, 0, 224, 1, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, + 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, + 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, + 95, 68, 69, 80, 84, 72, 0, 171, 171, 171, 83, 72, 68, 82, 120, 0, 0, 0, 64, + 0, 0, 0, 30, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, + 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, + 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 2, 1, 192, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 4, 1, 192, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h new file mode 100644 index 0000000000..c8a472e9b6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2d11ps.h @@ -0,0 +1,103 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 1, 0, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0.x, c0.xxxy, c0.yyyx + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.xyz, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughLum2D[] = { + 68, 88, 66, 67, 241, 199, 66, 51, 118, 205, 236, 165, 244, 231, 234, 126, 203, 25, 231, + 134, 1, 0, 0, 0, 20, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 208, 0, + 0, 0, 108, 1, 0, 0, 232, 1, 0, 0, 136, 2, 0, 0, 224, 2, 0, 0, 65, + 111, 110, 57, 144, 0, 0, 0, 144, 0, 0, 0, 0, 2, 255, 255, 104, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 0, 128, 0, 0, 64, 160, 0, 0, + 21, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, + 72, 68, 82, 148, 0, 0, 0, 64, 0, 0, 0, 37, 0, 0, 0, 90, 0, 0, 3, + 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, + 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, + 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 152, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, + 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, + 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, + 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, + 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2darray11ps.h new file mode 100644 index 0000000000..4741497d93 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum2darray11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov o0.xyz, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughLum2DArray[] = { + 68, 88, 66, 67, 84, 131, 205, 28, 3, 168, 120, 6, 89, 75, 169, 140, 154, 126, 61, + 31, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 204, 0, 0, 0, 64, 0, 0, 0, 51, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h new file mode 100644 index 0000000000..5c9ffc039a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h @@ -0,0 +1,79 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov o0.xyz, r0.xxxx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughLum3D[] = { + 68, 88, 66, 67, 15, 80, 145, 76, 93, 127, 194, 208, 106, 29, 26, 87, 147, 62, 128, + 143, 1, 0, 0, 0, 168, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 44, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 148, 0, 0, 0, 64, 0, 0, 0, 37, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, + 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h new file mode 100644 index 0000000000..6229e57ea2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2d11ps.h @@ -0,0 +1,98 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mov r0, r0.xxxw + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.xyzw, r0.xxxw +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_PassthroughLumAlpha2D[] = { + 68, 88, 66, 67, 19, 109, 76, 235, 225, 193, 54, 241, 78, 207, 77, 62, 148, 127, 172, + 73, 1, 0, 0, 0, 224, 2, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 176, 0, + 0, 0, 56, 1, 0, 0, 180, 1, 0, 0, 84, 2, 0, 0, 172, 2, 0, 0, 65, + 111, 110, 57, 112, 0, 0, 0, 112, 0, 0, 0, 0, 2, 255, 255, 72, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 1, 0, 0, 2, + 0, 0, 15, 128, 0, 0, 192, 128, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, + 128, 255, 255, 0, 0, 83, 72, 68, 82, 128, 0, 0, 0, 64, 0, 0, 0, 32, 0, + 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, + 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, + 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, + 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, + 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 6, 12, 16, 0, + 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, + 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, + 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, + 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, + 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, + 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, + 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, + 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2darray11ps.h new file mode 100644 index 0000000000..cdc91561bc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha2darray11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov o0.xyzw, r0.xxxw +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_PassthroughLumAlpha2DArray[] = { + 68, 88, 66, 67, 117, 33, 119, 91, 15, 156, 83, 232, 200, 231, 183, 116, 40, 238, 79, + 163, 1, 0, 0, 0, 204, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 80, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 184, 0, 0, 0, 64, 0, 0, 0, 46, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 6, 12, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h new file mode 100644 index 0000000000..941b5b2b86 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h @@ -0,0 +1,77 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov o0.xyzw, r0.xxxw +ret +// Approximately 3 instruction slots used +#endif + +const BYTE g_PS_PassthroughLumAlpha3D[] = { + 68, 88, 66, 67, 158, 22, 231, 90, 211, 81, 99, 1, 181, 209, 159, 145, 140, 162, 254, + 17, 1, 0, 0, 0, 148, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 24, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 128, 0, 0, 0, 64, 0, 0, 0, 32, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 242, 32, 16, 0, 0, 0, 0, 0, 6, 12, 16, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h new file mode 100644 index 0000000000..1b41ed1602 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2d11ps.h @@ -0,0 +1,104 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 1, 0, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0.x, c0.xyyy, c0.yyyx + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2D[] = { + 68, 88, 66, 67, 14, 165, 206, 90, 117, 2, 221, 45, 225, 30, 128, 173, 62, 238, 39, + 64, 1, 0, 0, 0, 32, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 208, 0, + 0, 0, 120, 1, 0, 0, 244, 1, 0, 0, 148, 2, 0, 0, 236, 2, 0, 0, 65, + 111, 110, 57, 144, 0, 0, 0, 144, 0, 0, 0, 0, 2, 255, 255, 104, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 0, 128, 0, 0, 84, 160, 0, 0, + 21, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, + 72, 68, 82, 160, 0, 0, 0, 64, 0, 0, 0, 40, 0, 0, 0, 90, 0, 0, 3, + 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, + 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, + 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, + 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, + 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, + 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, + 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, + 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, + 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, + 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, + 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, + 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darray11ps.h new file mode 100644 index 0000000000..a5e3d5e52e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darray11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2DArray[] = { + 68, 88, 66, 67, 67, 125, 115, 154, 244, 73, 25, 207, 88, 140, 76, 46, 206, 166, 161, + 193, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, 0, 0, 0, 54, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayi11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayi11ps.h new file mode 100644 index 0000000000..eb41a93e37 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayi11ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2darray (sint,sint,sint,sint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2DArrayI[] = { + 68, 88, 66, 67, 200, 92, 148, 185, 17, 79, 183, 61, 19, 121, 215, 3, 144, 133, 210, + 72, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 36, 1, 0, 0, 64, 0, 0, 0, 73, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayui11ps.h new file mode 100644 index 0000000000..12825c89e6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2darrayui11ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2darray (uint,uint,uint,uint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2DArrayUI[] = { + 68, 88, 66, 67, 201, 224, 137, 9, 164, 198, 146, 11, 60, 99, 27, 27, 235, 209, 108, + 242, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 36, 1, 0, 0, 64, 0, 0, 0, 73, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h new file mode 100644 index 0000000000..ea6bbcd460 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2di11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2d (sint,sint,sint,sint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2DI[] = { + 68, 88, 66, 67, 8, 16, 169, 157, 145, 179, 119, 85, 36, 37, 85, 107, 44, 112, 158, + 100, 1, 0, 0, 0, 200, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 76, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 12, 1, 0, 0, 64, 0, 0, + 0, 67, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h new file mode 100644 index 0000000000..bc034faaf6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr2dui11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2d (uint,uint,uint,uint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughR2DUI[] = { + 68, 88, 66, 67, 6, 47, 175, 167, 62, 144, 171, 206, 77, 165, 245, 226, 135, 124, 142, + 188, 1, 0, 0, 0, 200, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 76, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 12, 1, 0, 0, 64, 0, 0, + 0, 67, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h new file mode 100644 index 0000000000..010e3eae14 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3d11ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughR3D[] = { + 68, 88, 66, 67, 134, 101, 76, 73, 205, 199, 65, 249, 170, 201, 40, 128, 129, 87, 93, + 148, 1, 0, 0, 0, 180, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 56, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 160, 0, 0, 0, 64, 0, 0, 0, 40, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h new file mode 100644 index 0000000000..447690e35e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3di11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture3d (sint,sint,sint,sint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughR3DI[] = { + 68, 88, 66, 67, 250, 224, 56, 242, 8, 157, 92, 236, 205, 252, 68, 242, 80, 46, 223, + 98, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h new file mode 100644 index 0000000000..040b333116 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughr3dui11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture3d (uint,uint,uint,uint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.x, r0.x +mov o0.yzw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughR3DUI[] = { + 68, 88, 66, 67, 125, 15, 246, 192, 16, 228, 182, 55, 2, 24, 75, 71, 132, 253, 233, + 61, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 226, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h new file mode 100644 index 0000000000..a9373f69ab --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h @@ -0,0 +1,104 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 1, 0, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0.xyxx, c0.xxyy, c0.yyyx + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2D[] = { + 68, 88, 66, 67, 151, 54, 111, 200, 187, 200, 177, 214, 12, 69, 246, 113, 254, 31, 23, + 45, 1, 0, 0, 0, 32, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 208, 0, + 0, 0, 120, 1, 0, 0, 244, 1, 0, 0, 148, 2, 0, 0, 236, 2, 0, 0, 65, + 111, 110, 57, 144, 0, 0, 0, 144, 0, 0, 0, 0, 2, 255, 255, 104, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 4, 128, 0, 0, 80, 160, 0, 0, + 21, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, + 72, 68, 82, 160, 0, 0, 0, 64, 0, 0, 0, 40, 0, 0, 0, 90, 0, 0, 3, + 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, + 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, + 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, + 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, + 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, + 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, + 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, + 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, + 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, + 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, + 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, + 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, + 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darray11ps.h new file mode 100644 index 0000000000..e97f66a770 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darray11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2DArray[] = { + 68, 88, 66, 67, 20, 85, 120, 206, 181, 139, 167, 245, 44, 89, 37, 135, 242, 39, 108, + 150, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, 0, 0, 0, 54, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayi11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayi11ps.h new file mode 100644 index 0000000000..f7ac20960d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayi11ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2darray (sint,sint,sint,sint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2DArrayI[] = { + 68, 88, 66, 67, 221, 150, 25, 83, 110, 171, 138, 218, 81, 94, 8, 224, 63, 191, 253, + 25, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 36, 1, 0, 0, 64, 0, 0, 0, 73, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayui11ps.h new file mode 100644 index 0000000000..2caa7b3b80 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2darrayui11ps.h @@ -0,0 +1,90 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2darray (uint,uint,uint,uint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2DArrayUI[] = { + 68, 88, 66, 67, 120, 173, 124, 47, 122, 95, 175, 210, 44, 74, 36, 182, 242, 25, 225, + 20, 1, 0, 0, 0, 16, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 148, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 36, 1, 0, 0, 64, 0, 0, 0, 73, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h new file mode 100644 index 0000000000..25f0638e82 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2di11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2d (sint,sint,sint,sint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2DI[] = { + 68, 88, 66, 67, 161, 76, 0, 115, 100, 69, 2, 128, 179, 140, 112, 55, 172, 151, 175, + 231, 1, 0, 0, 0, 200, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 76, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 12, 1, 0, 0, 64, 0, 0, + 0, 67, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h new file mode 100644 index 0000000000..cf9f8c793b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2dui11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2d (uint,uint,uint,uint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG2DUI[] = { + 68, 88, 66, 67, 161, 19, 0, 215, 231, 88, 50, 183, 124, 43, 107, 122, 144, 150, 193, + 168, 1, 0, 0, 0, 200, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 76, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 12, 1, 0, 0, 64, 0, 0, + 0, 67, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, + 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h new file mode 100644 index 0000000000..f9d91f7bd7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3d11ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG3D[] = { + 68, 88, 66, 67, 234, 174, 205, 77, 197, 154, 113, 172, 235, 131, 32, 212, 121, 65, 136, + 164, 1, 0, 0, 0, 180, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 56, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 160, 0, 0, 0, 64, 0, 0, 0, 40, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h new file mode 100644 index 0000000000..53b5685cd6 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3di11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture3d (sint,sint,sint,sint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG3DI[] = { + 68, 88, 66, 67, 215, 62, 152, 236, 50, 188, 41, 213, 133, 37, 41, 228, 13, 20, 9, + 166, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h new file mode 100644 index 0000000000..de7c00b8cb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg3dui11ps.h @@ -0,0 +1,86 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture3d (uint,uint,uint,uint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xy, r0.xyxx +mov o0.zw, l(0,0,0,0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRG3DUI[] = { + 68, 88, 66, 67, 136, 113, 120, 69, 210, 200, 206, 216, 193, 132, 168, 220, 72, 141, 170, + 116, 1, 0, 0, 0, 236, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 112, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, 0, 64, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 50, 32, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, + 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h new file mode 100644 index 0000000000..7187de985f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h @@ -0,0 +1,103 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 1, 0, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0.xyzx, c0.xxxy, c0.yyyx + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov o0.xyz, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2D[] = { + 68, 88, 66, 67, 250, 48, 137, 17, 146, 199, 249, 10, 198, 141, 227, 123, 246, 248, 120, + 90, 1, 0, 0, 0, 20, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 208, 0, + 0, 0, 108, 1, 0, 0, 232, 1, 0, 0, 136, 2, 0, 0, 224, 2, 0, 0, 65, + 111, 110, 57, 144, 0, 0, 0, 144, 0, 0, 0, 0, 2, 255, 255, 104, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 36, 128, 0, 0, 64, 160, 0, 0, + 21, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, + 72, 68, 82, 148, 0, 0, 0, 64, 0, 0, 0, 37, 0, 0, 0, 90, 0, 0, 3, + 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, + 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, + 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, + 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 152, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, + 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, + 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, + 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, + 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d_565_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d_565_11ps.h new file mode 100644 index 0000000000..7807225fa7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d_565_11ps.h @@ -0,0 +1,118 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 31, 63, 0.5, 1 + def c1, 0.0322580636, 0.0158730168, 0, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0.xyz, r0, c0.xyxw, c0.z + frc r1.xyz, r0 + add r0.xyz, r0, -r1 + mul r0.xyz, r0, c1.xyxw + mov r0.w, c0.w + mov oC0, r0 + +// approximately 7 instruction slots used (1 texture, 6 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2D_565[] = { + 68, 88, 66, 67, 120, 69, 206, 120, 97, 29, 104, 168, 87, 8, 112, 9, 57, 119, 88, + 99, 1, 0, 0, 0, 180, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 32, 1, + 0, 0, 12, 2, 0, 0, 136, 2, 0, 0, 40, 3, 0, 0, 128, 3, 0, 0, 65, + 111, 110, 57, 224, 0, 0, 0, 224, 0, 0, 0, 0, 2, 255, 255, 184, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 0, 63, 0, 0, 128, 63, 81, + 0, 0, 5, 1, 0, 15, 160, 8, 33, 4, 61, 33, 8, 130, 60, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, + 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, + 228, 176, 0, 8, 228, 160, 4, 0, 0, 4, 0, 0, 7, 128, 0, 0, 228, 128, 0, + 0, 196, 160, 0, 0, 170, 160, 19, 0, 0, 2, 1, 0, 7, 128, 0, 0, 228, 128, + 2, 0, 0, 3, 0, 0, 7, 128, 0, 0, 228, 128, 1, 0, 228, 129, 5, 0, 0, + 3, 0, 0, 7, 128, 0, 0, 228, 128, 1, 0, 196, 160, 1, 0, 0, 2, 0, 0, + 8, 128, 0, 0, 255, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, + 255, 0, 0, 83, 72, 68, 82, 228, 0, 0, 0, 64, 0, 0, 0, 57, 0, 0, 0, + 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, + 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, + 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, + 0, 0, 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, + 0, 0, 0, 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, + 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, + 4, 61, 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, + 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, + 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, + 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, + 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, + 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, + 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, + 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, + 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, + 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, + 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray11ps.h new file mode 100644 index 0000000000..22fc48b370 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov o0.xyz, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DArray[] = { + 68, 88, 66, 67, 26, 40, 103, 223, 174, 169, 46, 176, 180, 125, 61, 98, 234, 113, 13, + 48, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 204, 0, 0, 0, 64, 0, 0, 0, 51, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray_565_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray_565_11ps.h new file mode 100644 index 0000000000..93c8675762 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darray_565_11ps.h @@ -0,0 +1,91 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DArray_565[] = { + 68, 88, 66, 67, 185, 16, 51, 115, 29, 189, 183, 180, 27, 245, 224, 140, 177, 41, 213, + 79, 1, 0, 0, 0, 48, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 180, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 28, 1, 0, 0, 64, 0, 0, 0, 71, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, 0, 0, 0, + 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, 4, 61, 0, + 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayi11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayi11ps.h new file mode 100644 index 0000000000..da517dedc7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayi11ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2darray (sint,sint,sint,sint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DArrayI[] = { + 68, 88, 66, 67, 176, 173, 178, 89, 17, 53, 136, 1, 253, 33, 56, 172, 20, 106, 131, + 127, 1, 0, 0, 0, 4, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 136, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 24, 1, 0, 0, 64, 0, 0, 0, 70, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayui11ps.h new file mode 100644 index 0000000000..3b33754c28 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2darrayui11ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2darray (uint,uint,uint,uint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(1) +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DArrayUI[] = { + 68, 88, 66, 67, 239, 124, 234, 46, 158, 116, 212, 164, 152, 122, 22, 86, 114, 177, 255, + 160, 1, 0, 0, 0, 4, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 136, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 24, 1, 0, 0, 64, 0, 0, 0, 70, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, + 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h new file mode 100644 index 0000000000..79ff3c4168 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2d (sint,sint,sint,sint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DI[] = { + 68, 88, 66, 67, 190, 234, 127, 190, 151, 71, 156, 183, 160, 74, 156, 153, 91, 12, 95, + 85, 1, 0, 0, 0, 188, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 64, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, + 0, 64, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h new file mode 100644 index 0000000000..74ef0a2236 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2d (uint,uint,uint,uint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB2DUI[] = { + 68, 88, 66, 67, 240, 47, 31, 84, 32, 155, 233, 36, 235, 43, 92, 251, 152, 13, 113, + 169, 1, 0, 0, 0, 188, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 64, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 0, 1, 0, 0, 64, 0, 0, + 0, 64, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h new file mode 100644 index 0000000000..b533c74d77 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d11ps.h @@ -0,0 +1,79 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov o0.xyz, r0.xyzx +mov o0.w, l(1.000000) +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB3D[] = { + 68, 88, 66, 67, 121, 178, 78, 177, 99, 144, 108, 81, 39, 245, 135, 91, 55, 31, 56, + 111, 1, 0, 0, 0, 168, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 44, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 148, 0, 0, 0, 64, 0, 0, 0, 37, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, + 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d_565_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d_565_11ps.h new file mode 100644 index 0000000000..5222d51cc3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3d_565_11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyz, r0.xyzx, l(31.000000, 63.000000, 31.000000, 0.000000) +round_ne r0.xyz, r0.xyzx +mul o0.xyz, r0.xyzx, l(0.032258, 0.015873, 0.032258, 0.000000) +mov o0.w, l(1.000000) +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB3D_565[] = { + 68, 88, 66, 67, 190, 139, 108, 54, 112, 70, 128, 98, 155, 40, 89, 132, 48, 127, 91, + 244, 1, 0, 0, 0, 248, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 124, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 228, 0, 0, 0, 64, 0, 0, 0, 57, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 124, 66, 0, 0, 248, 65, 0, 0, 0, + 0, 64, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 10, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, + 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 33, 8, 130, 60, 8, 33, 4, 61, + 0, 0, 0, 0, 54, 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, + 0, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h new file mode 100644 index 0000000000..9e590b3ebb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3di11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture3d (sint,sint,sint,sint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB3DI[] = { + 68, 88, 66, 67, 122, 80, 149, 91, 225, 62, 16, 173, 12, 194, 248, 74, 159, 33, 217, + 135, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 244, 0, 0, 0, 64, 0, 0, 0, 61, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h new file mode 100644 index 0000000000..534b9d9faa --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb3dui11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture3d (uint,uint,uint,uint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov o0.xyz, r0.xyzx +mov o0.w, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGB3DUI[] = { + 68, 88, 66, 67, 177, 156, 23, 109, 67, 253, 176, 134, 182, 213, 173, 70, 148, 235, 60, + 205, 1, 0, 0, 0, 224, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 100, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 244, 0, 0, 0, 64, 0, 0, 0, 61, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 114, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h new file mode 100644 index 0000000000..f8b36063f2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h @@ -0,0 +1,93 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mov oC0, r0 + +// approximately 2 instruction slots used (1 texture, 1 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +sample o0.xyzw, v1.xyxx, t0.xyzw, s0 +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2D[] = { + 68, 88, 66, 67, 23, 65, 12, 167, 50, 71, 137, 250, 170, 67, 18, 134, 110, 213, 196, + 219, 1, 0, 0, 0, 184, 2, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 164, 0, + 0, 0, 16, 1, 0, 0, 140, 1, 0, 0, 44, 2, 0, 0, 132, 2, 0, 0, 65, + 111, 110, 57, 100, 0, 0, 0, 100, 0, 0, 0, 0, 2, 255, 255, 60, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 1, 0, 0, 2, + 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, 72, 68, 82, 100, 0, 0, + 0, 64, 0, 0, 0, 25, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, + 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, + 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, + 0, 0, 0, 0, 69, 0, 0, 9, 242, 32, 16, 0, 0, 0, 0, 0, 70, 16, 16, + 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, + 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, + 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, + 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, + 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, + 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, + 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, + 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, + 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, + 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, + 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_4444_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_4444_11ps.h new file mode 100644 index 0000000000..2f94f13c12 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_4444_11ps.h @@ -0,0 +1,112 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 15, 0.5, 0.0666666701, 0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0, c0.x, c0.y + frc r1, r0 + add r0, r0, -r1 + mul r0, r0, c0.z + mov oC0, r0 + +// approximately 6 instruction slots used (1 texture, 5 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2D_4444[] = { + 68, 88, 66, 67, 188, 56, 0, 47, 220, 85, 24, 210, 59, 166, 131, 1, 131, 90, 227, + 171, 1, 0, 0, 0, 124, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 252, 0, + 0, 0, 212, 1, 0, 0, 80, 2, 0, 0, 240, 2, 0, 0, 72, 3, 0, 0, 65, + 111, 110, 57, 188, 0, 0, 0, 188, 0, 0, 0, 0, 2, 255, 255, 148, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 112, 65, 0, 0, 0, 63, 137, 136, 136, 61, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 228, 128, 0, 0, 0, 160, 0, 0, + 85, 160, 19, 0, 0, 2, 1, 0, 15, 128, 0, 0, 228, 128, 2, 0, 0, 3, 0, + 0, 15, 128, 0, 0, 228, 128, 1, 0, 228, 129, 5, 0, 0, 3, 0, 0, 15, 128, + 0, 0, 228, 128, 0, 0, 170, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, + 128, 255, 255, 0, 0, 83, 72, 68, 82, 208, 0, 0, 0, 64, 0, 0, 0, 52, 0, + 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, + 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, + 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, + 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, + 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, + 65, 0, 0, 112, 65, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, + 137, 136, 136, 61, 137, 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, + 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, + 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, + 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, + 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, + 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, + 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_5551_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_5551_11ps.h new file mode 100644 index 0000000000..44966d6a9b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d_5551_11ps.h @@ -0,0 +1,112 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + def c0, 31, 1, 0.5, 0.0322580636 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mad r0, r0, c0.xxxy, c0.z + frc r1, r0 + add r0, r0, -r1 + mul r0, r0, c0.wwwy + mov oC0, r0 + +// approximately 6 instruction slots used (1 texture, 5 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2D_5551[] = { + 68, 88, 66, 67, 202, 32, 204, 89, 54, 13, 5, 203, 247, 109, 207, 183, 162, 90, 24, + 32, 1, 0, 0, 0, 124, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 252, 0, + 0, 0, 212, 1, 0, 0, 80, 2, 0, 0, 240, 2, 0, 0, 72, 3, 0, 0, 65, + 111, 110, 57, 188, 0, 0, 0, 188, 0, 0, 0, 0, 2, 255, 255, 148, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 81, 0, 0, 5, 0, 0, + 15, 160, 0, 0, 248, 65, 0, 0, 128, 63, 0, 0, 0, 63, 8, 33, 4, 61, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 228, 128, 0, 0, 64, 160, 0, 0, + 170, 160, 19, 0, 0, 2, 1, 0, 15, 128, 0, 0, 228, 128, 2, 0, 0, 3, 0, + 0, 15, 128, 0, 0, 228, 128, 1, 0, 228, 129, 5, 0, 0, 3, 0, 0, 15, 128, + 0, 0, 228, 128, 0, 0, 127, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, + 128, 255, 255, 0, 0, 83, 72, 68, 82, 208, 0, 0, 0, 64, 0, 0, 0, 52, 0, + 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, + 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, + 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, + 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, + 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, + 0, 0, 0, 56, 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, + 65, 0, 0, 128, 63, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, + 8, 33, 4, 61, 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 82, 68, 69, 70, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, + 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, + 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, + 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, + 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, + 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, + 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, + 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, + 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray11ps.h new file mode 100644 index 0000000000..227aab3bf9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray11ps.h @@ -0,0 +1,81 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample o0.xyzw, r0.xyzx, t0.xyzw, s0 +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DArray[] = { + 68, 88, 66, 67, 200, 215, 233, 151, 66, 46, 221, 224, 83, 242, 34, 162, 166, 5, 137, + 148, 1, 0, 0, 0, 184, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 60, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 164, 0, 0, 0, 64, 0, 0, 0, 41, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 32, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_4444_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_4444_11ps.h new file mode 100644 index 0000000000..24011717c7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_4444_11ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DArray_4444[] = { + 68, 88, 66, 67, 88, 17, 60, 194, 201, 5, 168, 96, 74, 117, 234, 137, 214, 224, 224, + 134, 1, 0, 0, 0, 28, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 160, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 8, 1, 0, 0, 64, 0, 0, 0, 66, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, + 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, 137, + 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_5551_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_5551_11ps.h new file mode 100644 index 0000000000..f6335bccef --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darray_5551_11ps.h @@ -0,0 +1,89 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DArray_5551[] = { + 68, 88, 66, 67, 68, 140, 194, 251, 165, 142, 204, 154, 232, 236, 200, 233, 255, 120, 4, + 27, 1, 0, 0, 0, 28, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 160, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 8, 1, 0, 0, 64, 0, 0, 0, 66, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 86, 0, + 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, + 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, 0, + 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 2, + 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 128, 63, + 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, + 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, 8, 33, 4, 61, 0, + 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayi11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayi11ps.h new file mode 100644 index 0000000000..457935a252 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayi11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2darray (sint,sint,sint,sint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DArrayI[] = { + 68, 88, 66, 67, 215, 68, 211, 98, 73, 229, 148, 22, 136, 6, 112, 36, 206, 148, 145, + 188, 1, 0, 0, 0, 220, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 96, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 240, 0, 0, 0, 64, 0, 0, 0, 60, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayui11ps.h new file mode 100644 index 0000000000..58b67ac728 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2darrayui11ps.h @@ -0,0 +1,85 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2darray t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2darray (uint,uint,uint,uint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DArrayUI[] = { + 68, 88, 66, 67, 31, 32, 146, 134, 107, 181, 50, 167, 97, 108, 64, 57, 238, 167, 69, + 217, 1, 0, 0, 0, 220, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 96, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 240, 0, 0, 0, 64, 0, 0, 0, 60, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, + 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, + 0, 1, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h new file mode 100644 index 0000000000..eb0ebbd6ea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h @@ -0,0 +1,78 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture2d (sint,sint,sint,sint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DI[] = { + 68, 88, 66, 67, 11, 194, 121, 174, 53, 241, 53, 229, 116, 76, 99, 226, 54, 79, 165, + 216, 1, 0, 0, 0, 148, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 24, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, 0, 0, + 0, 54, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dms11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dms11ps.h new file mode 100644 index 0000000000..76361532d2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dms11ps.h @@ -0,0 +1,80 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureF_MS texture float4 2dMS t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// SV_SAMPLEINDEX 0 x 2 SAMPLE uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// Pixel Shader runs at sample frequency +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_input_ps_sgv constant v2.x, sampleIndex +dcl_output o0.xyzw +dcl_temps 1 +ftou r0.xy, v1.xyxx +mov r0.zw, l(0,0,0,0) +ldms o0.xyzw, r0.xyzw, t0.xyzw, v2.x +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DMS[] = { + 68, 88, 66, 67, 49, 75, 69, 135, 188, 202, 223, 102, 144, 42, 4, 30, 173, 255, 143, + 210, 1, 0, 0, 0, 136, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 40, 1, 0, 0, 92, 1, 0, 0, 12, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 72, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 77, 83, 0, 77, + 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, + 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, + 0, 73, 83, 71, 78, 116, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 101, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, + 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 83, 86, 95, 83, + 65, 77, 80, 76, 69, 73, 78, 68, 69, 88, 0, 79, 83, 71, 78, 44, 0, 0, 0, + 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, + 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 168, 0, 0, 0, 65, 0, 0, 0, 42, + 0, 0, 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, + 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 99, 8, 0, + 4, 18, 16, 16, 0, 2, 0, 0, 0, 10, 0, 0, 0, 101, 0, 0, 3, 242, 32, + 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 28, 0, 0, 5, 50, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 8, + 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, 242, 32, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 10, + 16, 16, 0, 2, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h new file mode 100644 index 0000000000..31f84d0d74 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h @@ -0,0 +1,78 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 2d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture2d (uint,uint,uint,uint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA2DUI[] = { + 68, 88, 66, 67, 116, 109, 92, 124, 46, 28, 237, 165, 173, 42, 6, 53, 183, 101, 128, + 93, 1, 0, 0, 0, 148, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 24, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 216, 0, 0, 0, 64, 0, 0, + 0, 54, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, + 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h new file mode 100644 index 0000000000..4aef441bcd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d11ps.h @@ -0,0 +1,74 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +sample o0.xyzw, v2.xyzx, t0.xyzw, s0 +ret +// Approximately 2 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA3D[] = { + 68, 88, 66, 67, 68, 93, 216, 66, 165, 49, 226, 52, 230, 199, 150, 143, 253, 53, 233, + 213, 1, 0, 0, 0, 120, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 252, 1, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 100, 0, 0, 0, 64, 0, 0, 0, 25, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 69, 0, 0, 9, 242, 32, 16, + 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, 0, 0, 70, 126, 16, 0, 0, 0, + 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_4444_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_4444_11ps.h new file mode 100644 index 0000000000..d6c7a28333 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_4444_11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(15.000000, 15.000000, 15.000000, 15.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.066667, 0.066667, 0.066667, 0.066667) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA3D_4444[] = { + 68, 88, 66, 67, 244, 22, 101, 89, 172, 184, 153, 143, 94, 198, 255, 75, 136, 76, 172, + 69, 1, 0, 0, 0, 228, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 104, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 208, 0, 0, 0, 64, 0, 0, 0, 52, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, 65, 0, 0, 112, + 65, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, + 0, 0, 0, 2, 64, 0, 0, 137, 136, 136, 61, 137, 136, 136, 61, 137, 136, 136, 61, + 137, 136, 136, 61, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_5551_11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_5551_11ps.h new file mode 100644 index 0000000000..3329c4d2ce --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3d_5551_11ps.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF texture float4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mul r0.xyzw, r0.xyzw, l(31.000000, 31.000000, 31.000000, 1.000000) +round_ne r0.xyzw, r0.xyzw +mul o0.xyzw, r0.xyzw, l(0.032258, 0.032258, 0.032258, 1.000000) +ret +// Approximately 5 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA3D_5551[] = { + 68, 88, 66, 67, 84, 84, 9, 48, 70, 52, 100, 237, 108, 219, 183, 20, 215, 148, 144, + 173, 1, 0, 0, 0, 228, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 212, 0, + 0, 0, 92, 1, 0, 0, 144, 1, 0, 0, 104, 2, 0, 0, 82, 68, 69, 70, 152, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 83, 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 171, 171, 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, + 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, + 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, + 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, + 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, + 171, 83, 72, 68, 82, 208, 0, 0, 0, 64, 0, 0, 0, 52, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, + 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, + 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 248, 65, 0, 0, 128, + 63, 64, 0, 0, 5, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 10, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, + 0, 0, 0, 2, 64, 0, 0, 8, 33, 4, 61, 8, 33, 4, 61, 8, 33, 4, 61, + 0, 0, 128, 63, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 5, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h new file mode 100644 index 0000000000..81adb14ca9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3di11ps.h @@ -0,0 +1,81 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI texture sint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_resource_texture3d (sint,sint,sint,sint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA3DI[] = { + 68, 88, 66, 67, 112, 154, 25, 211, 170, 223, 11, 97, 14, 10, 139, 203, 225, 190, 33, + 158, 1, 0, 0, 0, 184, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 60, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 69, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 73, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 204, 0, 0, 0, 64, 0, 0, 0, 51, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h new file mode 100644 index 0000000000..31bc39204d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba3dui11ps.h @@ -0,0 +1,81 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI texture uint4 3d t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_resource_texture3d (uint,uint,uint,uint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld o0.xyzw, r0.xyzw, t0.xyzw +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBA3DUI[] = { + 68, 88, 66, 67, 136, 72, 192, 109, 253, 59, 232, 36, 69, 34, 127, 153, 17, 12, 205, + 209, 1, 0, 0, 0, 184, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 52, 1, 0, 0, 104, 1, 0, 0, 60, 2, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 70, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 85, 73, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, + 171, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, + 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, + 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, + 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, + 72, 68, 82, 204, 0, 0, 0, 64, 0, 0, 0, 51, 0, 0, 0, 88, 40, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 114, 16, 16, + 0, 2, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, + 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, + 7, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, + 16, 0, 2, 0, 0, 0, 27, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, + 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 45, 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, + 0, 70, 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvecolor2dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvecolor2dps.h new file mode 100644 index 0000000000..8283ea9c4c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvecolor2dps.h @@ -0,0 +1,103 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureF_MS texture float4 2dMS t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 4 +resinfo_uint r0.xy, l(0), t0.xyzw +sampleinfo_uint r0.z, t0.x +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r1.xy, r0.xyxx +mov r1.zw, l(0,0,0,0) +mov r2.xyzw, l(0,0,0,0) +mov r0.x, l(0) +loop + uge r0.y, r0.x, r0.z + breakc_nz r0.y + ldms r3.xyzw, r1.xyzw, t0.xyzw, r0.x + add r2.xyzw, r2.xyzw, r3.xyzw + iadd r0.x, r0.x, l(1) +endloop +sampleinfo r0.x, t0.x +div o0.xyzw, r2.xyzw, r0.xxxx +ret +// Approximately 18 instruction slots used +#endif + +const BYTE g_PS_ResolveColor2D[] = { + 68, 88, 66, 67, 93, 61, 55, 147, 13, 181, 1, 129, 207, 120, 176, 100, 210, 126, 243, + 242, 1, 0, 0, 0, 128, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 172, 0, + 0, 0, 4, 1, 0, 0, 56, 1, 0, 0, 4, 3, 0, 0, 82, 68, 69, 70, 112, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 72, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 84, 101, 120, 116, 117, 114, 101, 70, 95, 77, 83, 0, 77, + 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, + 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, + 0, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, + 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, + 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, + 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 196, 1, 0, 0, 65, 0, 0, + 0, 113, 0, 0, 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, 16, 0, 0, 0, + 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, + 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 4, 0, 0, 0, + 61, 16, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 111, 8, 0, 5, 66, 0, 16, 0, 0, 0, + 0, 0, 10, 112, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, + 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, + 0, 28, 0, 0, 5, 50, 0, 16, 0, 1, 0, 0, 0, 70, 0, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 1, 0, 0, 0, 2, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 8, + 242, 0, 16, 0, 2, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 18, 0, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 48, 0, 0, 1, 80, 0, 0, 7, 34, + 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 42, 0, 16, 0, + 0, 0, 0, 0, 3, 0, 4, 3, 26, 0, 16, 0, 0, 0, 0, 0, 46, 0, 0, + 9, 242, 0, 16, 0, 3, 0, 0, 0, 70, 14, 16, 0, 1, 0, 0, 0, 70, 126, + 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 7, 242, + 0, 16, 0, 2, 0, 0, 0, 70, 14, 16, 0, 2, 0, 0, 0, 70, 14, 16, 0, + 3, 0, 0, 0, 30, 0, 0, 7, 18, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, + 0, 0, 0, 0, 0, 1, 64, 0, 0, 1, 0, 0, 0, 22, 0, 0, 1, 111, 0, + 0, 5, 18, 0, 16, 0, 0, 0, 0, 0, 10, 112, 16, 0, 0, 0, 0, 0, 14, + 0, 0, 7, 242, 32, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 2, 0, 0, 0, + 6, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, + 0, 18, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h new file mode 100644 index 0000000000..0f986c7843 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h @@ -0,0 +1,81 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Depth texture float 2dMS t0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Depth 0 N/A oDepth DEPTH float YES +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output oDepth +dcl_temps 1 +resinfo_uint r0.xy, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.x, r0.xyzw, t0.xyzw, l(0) +mov oDepth, r0.x +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_ResolveDepth[] = { + 68, 88, 66, 67, 133, 15, 63, 40, 192, 212, 199, 79, 7, 253, 243, 47, 246, 158, 13, + 45, 1, 0, 0, 0, 168, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 168, 0, + 0, 0, 0, 1, 0, 0, 52, 1, 0, 0, 44, 2, 0, 0, 82, 68, 69, 70, 108, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 66, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 68, 101, 112, 116, 104, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 73, 83, 71, + 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, + 3, 3, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, + 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 255, 255, 255, 255, 1, 14, 0, 0, 83, 86, 95, 68, 101, 112, 116, 104, + 0, 171, 171, 171, 83, 72, 68, 82, 240, 0, 0, 0, 65, 0, 0, 0, 60, 0, 0, + 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 2, 1, + 192, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 50, 0, 16, 0, + 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, + 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, + 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, + 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 28, 0, 0, 5, 50, 0, 16, 0, + 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, + 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, 18, 0, 16, 0, 0, 0, 0, 0, 70, + 14, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 4, 1, 192, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h new file mode 100644 index 0000000000..449fbdbed9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h @@ -0,0 +1,92 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Depth texture float 2dMS t0 1 +// Stencil texture uint2 2dMS t1 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xy 0 TARGET float xy +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_resource_texture2dms(0) (uint,uint,uint,uint) t1 +dcl_input_ps linear v1.xy +dcl_output o0.xy +dcl_temps 1 +resinfo_uint r0.xy, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.z, r0.xyzw, t1.xzyw, l(0) +ldms r0.x, r0.xyww, t0.xyzw, l(0) +mov o0.x, r0.x +utof o0.y, r0.z +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_ResolveDepthStencil[] = { + 68, 88, 66, 67, 89, 136, 221, 180, 85, 229, 18, 205, 242, 112, 176, 35, 107, 34, 5, + 254, 1, 0, 0, 0, 32, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 208, 0, + 0, 0, 40, 1, 0, 0, 92, 1, 0, 0, 164, 2, 0, 0, 82, 68, 69, 70, 148, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 106, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 98, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, + 68, 101, 112, 116, 104, 0, 83, 116, 101, 110, 99, 105, 108, 0, 77, 105, 99, 114, 111, + 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, + 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 171, 171, 73, + 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, + 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, + 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, + 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, + 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 12, 0, 0, 83, 86, 95, 84, 97, 114, + 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 64, 1, 0, 0, 65, 0, 0, 0, 80, + 0, 0, 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, + 85, 85, 0, 0, 88, 32, 0, 4, 0, 112, 16, 0, 1, 0, 0, 0, 68, 68, 0, + 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 50, 32, + 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 50, + 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, + 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, + 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 28, 0, 0, 5, 50, + 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, + 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, 66, 0, 16, 0, 0, 0, + 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 134, 125, 16, 0, 1, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, 18, 0, 16, 0, 0, 0, 0, 0, + 70, 15, 16, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 1, 64, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 34, 32, 16, 0, 0, 0, 0, 0, 42, + 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, + 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h new file mode 100644 index 0000000000..162168be33 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h @@ -0,0 +1,83 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_VertexID 0 x 0 VERTID uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 xy 1 NONE float xy +// +vs_4_1 +dcl_globalFlags refactoringAllowed +dcl_immediateConstantBuffer { { -1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0}, + { -1.000000, -1.000000, 0, 0}, + { -1.000000, 1.000000, 0, 0}, + { 1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0} } +dcl_input_sgv v0.x, vertex_id +dcl_output_siv o0.xyzw, position +dcl_output o1.xy +dcl_temps 1 +mov o0.zw, l(0,0,0,1.000000) +mov r0.x, v0.x +mov o0.xy, icb[r0.x + 0].xyxx +add r0.y, l(1.000000), icb[r0.x + 0].x +add r0.x, l(1.000000), -icb[r0.x + 0].y +mul o1.xy, r0.yxyy, l(0.500000, 0.500000, 0.000000, 0.000000) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_VS_ResolveDepthStencil[] = { + 68, 88, 66, 67, 151, 71, 251, 149, 26, 9, 107, 111, 231, 137, 148, 94, 92, 2, 252, + 182, 1, 0, 0, 0, 244, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 128, 0, + 0, 0, 180, 0, 0, 0, 12, 1, 0, 0, 120, 2, 0, 0, 82, 68, 69, 70, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, + 86, 101, 114, 116, 101, 120, 73, 68, 0, 79, 83, 71, 78, 80, 0, 0, 0, 2, 0, + 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 12, 0, 0, 83, 86, 95, + 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 171, 171, 83, 72, 68, 82, 100, 1, 0, 0, 65, 0, 1, 0, 89, 0, 0, 0, 106, + 8, 0, 1, 53, 24, 0, 0, 26, 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 63, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 128, 191, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 63, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, + 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 4, 18, 16, 16, + 0, 0, 0, 0, 0, 6, 0, 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 101, 0, 0, 3, 50, 32, 16, 0, 1, 0, 0, 0, 104, + 0, 0, 2, 1, 0, 0, 0, 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, + 63, 54, 0, 0, 5, 18, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 50, 32, 16, 0, 0, 0, 0, 0, 70, 144, 144, 0, 10, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 34, 0, 16, 0, 0, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 128, 63, 10, 144, 144, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 0, 0, 0, 9, 18, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 128, 63, 26, 144, 144, 128, 65, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 10, 50, 32, 16, 0, 1, 0, 0, 0, 22, 5, 16, 0, 0, 0, 0, 0, + 2, 64, 0, 0, 0, 0, 0, 63, 0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, + 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h new file mode 100644 index 0000000000..0f96154858 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h @@ -0,0 +1,84 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Stencil texture uint2 2dMS t1 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xy 0 TARGET float xy +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (uint,uint,uint,uint) t1 +dcl_input_ps linear v1.xy +dcl_output o0.xy +dcl_temps 1 +resinfo_uint r0.xy, l(0), t1.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.x, r0.xyzw, t1.yxzw, l(0) +utof o0.y, r0.x +mov o0.x, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_ResolveStencil[] = { + 68, 88, 66, 67, 123, 66, 135, 11, 171, 75, 198, 85, 15, 70, 47, 122, 95, 167, 34, + 235, 1, 0, 0, 0, 196, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 168, 0, + 0, 0, 0, 1, 0, 0, 52, 1, 0, 0, 72, 2, 0, 0, 82, 68, 69, 70, 108, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 68, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, + 0, 0, 5, 0, 0, 0, 83, 116, 101, 110, 99, 105, 108, 0, 77, 105, 99, 114, 111, + 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, + 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, 73, 83, 71, + 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, + 3, 3, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, + 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 3, 12, 0, 0, 83, 86, 95, 84, 97, 114, 103, 101, + 116, 0, 171, 171, 83, 72, 68, 82, 12, 1, 0, 0, 65, 0, 0, 0, 67, 0, 0, + 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, 16, 0, 1, 0, 0, 0, 68, 68, + 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 50, + 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, + 50, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 1, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, + 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, + 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 28, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, 18, 0, 16, 0, 0, + 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 22, 126, 16, 0, 1, 0, 0, 0, + 1, 64, 0, 0, 0, 0, 0, 0, 86, 0, 0, 5, 34, 32, 16, 0, 0, 0, 0, + 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 5, 18, 32, 16, 0, 0, 0, + 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, + 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2darrayps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2darrayps.h new file mode 100644 index 0000000000..d3d5c0f0e3 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2darrayps.h @@ -0,0 +1,135 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF2DArray texture float4 2darray t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_sampler s0, mode_default +dcl_resource_texture2darray (float,float,float,float) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +utof r0.z, v1.x +mov r0.xy, v2.xyxx +sample r0.xyzw, r0.xyzx, t0.xyzw, s0 +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1.000000) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 18 instruction slots used +#endif + +const BYTE g_PS_SwizzleF2DArray[] = { + 68, 88, 66, 67, 43, 191, 227, 129, 77, 88, 223, 209, 64, 17, 168, 91, 78, 216, 210, + 134, 1, 0, 0, 0, 192, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 92, 1, + 0, 0, 228, 1, 0, 0, 24, 2, 0, 0, 68, 4, 0, 0, 82, 68, 69, 70, 32, + 1, 0, 0, 1, 0, 0, 0, 168, 0, 0, 0, 3, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 248, 0, 0, 0, 124, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 132, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 5, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 148, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 83, 97, 109, 112, 108, 101, + 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 50, 68, 65, 114, 114, 97, 121, 0, 83, + 119, 105, 122, 122, 108, 101, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, + 148, 0, 0, 0, 1, 0, 0, 0, 192, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 216, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, + 0, 0, 232, 0, 0, 0, 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, + 100, 105, 99, 101, 115, 0, 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, + 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, + 32, 49, 48, 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, + 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, + 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, + 82, 84, 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, + 69, 88, 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, + 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, + 84, 0, 171, 171, 83, 72, 68, 82, 36, 2, 0, 0, 64, 0, 0, 0, 137, 0, 0, + 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 90, 0, + 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 64, 0, 4, 0, 112, 16, 0, 0, + 0, 0, 0, 85, 85, 0, 0, 100, 8, 0, 4, 18, 16, 16, 0, 1, 0, 0, 0, + 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, + 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 105, 0, + 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 86, 0, 0, 5, 66, + 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, 0, 0, 54, 0, 0, 5, + 50, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, 69, 0, 0, + 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 126, + 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, + 48, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, + 0, 0, 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 18, 48, 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, + 0, 0, 0, 0, 128, 63, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, + 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, + 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, + 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 18, 0, 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 54, 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, + 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, + 0, 0, 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, + 130, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, + 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 18, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h new file mode 100644 index 0000000000..091c3e29ea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h @@ -0,0 +1,126 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF2D texture float4 2d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1.000000) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 16 instruction slots used +#endif + +const BYTE g_PS_SwizzleF2D[] = { + 68, 88, 66, 67, 221, 55, 186, 66, 171, 208, 86, 211, 37, 150, 98, 209, 236, 60, 108, + 41, 1, 0, 0, 0, 84, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 88, 1, + 0, 0, 176, 1, 0, 0, 228, 1, 0, 0, 216, 3, 0, 0, 82, 68, 69, 70, 28, + 1, 0, 0, 1, 0, 0, 0, 164, 0, 0, 0, 3, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 244, 0, 0, 0, 124, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 132, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 83, 97, 109, 112, 108, 101, + 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 50, 68, 0, 83, 119, 105, 122, 122, 108, + 101, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 171, 143, 0, 0, 0, + 1, 0, 0, 0, 188, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 212, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 228, 0, + 0, 0, 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, + 115, 0, 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, + 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, + 49, 0, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, + 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, + 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, + 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 236, 1, 0, 0, 64, 0, + 0, 0, 123, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, + 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, + 0, 2, 1, 0, 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, + 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, + 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 26, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 48, 32, 0, 0, 0, 0, 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, + 64, 0, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 54, 0, 0, 6, 18, 0, 16, + 0, 0, 0, 0, 0, 10, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 7, 18, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, + 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, + 26, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, + 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, + 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 0, 16, 0, 0, 0, 0, 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 7, 130, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, + 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, + 116, 0, 0, 0, 16, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef3dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef3dps.h new file mode 100644 index 0000000000..042cd18005 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef3dps.h @@ -0,0 +1,129 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// Sampler sampler NA NA s0 1 +// TextureF3D texture float4 3d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_sampler s0, mode_default +dcl_resource_texture3d (float,float,float,float) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +sample r0.xyzw, v2.xyzx, t0.xyzw, s0 +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1.000000) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 16 instruction slots used +#endif + +const BYTE g_PS_SwizzleF3D[] = { + 68, 88, 66, 67, 73, 214, 47, 221, 178, 220, 225, 86, 113, 45, 198, 41, 129, 110, 186, + 79, 1, 0, 0, 0, 132, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 88, 1, + 0, 0, 224, 1, 0, 0, 20, 2, 0, 0, 8, 4, 0, 0, 82, 68, 69, 70, 28, + 1, 0, 0, 1, 0, 0, 0, 164, 0, 0, 0, 3, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 244, 0, 0, 0, 124, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 132, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 8, + 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, + 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 83, 97, 109, 112, 108, 101, + 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 51, 68, 0, 83, 119, 105, 122, 122, 108, + 101, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 171, 143, 0, 0, 0, + 1, 0, 0, 0, 188, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 212, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 228, 0, + 0, 0, 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, + 115, 0, 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, + 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, + 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, + 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, + 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, + 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, + 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, + 83, 72, 68, 82, 236, 1, 0, 0, 64, 0, 0, 0, 123, 0, 0, 0, 89, 0, 0, + 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 90, 0, 0, 3, 0, 96, + 16, 0, 0, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, + 85, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, 0, 101, 0, 0, 3, + 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 105, 0, 0, + 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 69, 0, 0, 9, 242, 0, + 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, 0, 0, 70, 126, 16, 0, 0, + 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 42, + 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, 0, + 0, 128, 63, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, 0, + 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, + 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, + 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, + 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, + 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, + 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, 16, + 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, + 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 16, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2darrayps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2darrayps.h new file mode 100644 index 0000000000..08c48427e2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2darrayps.h @@ -0,0 +1,139 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI2DArray texture sint4 2darray t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture2darray (sint,sint,sint,sint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 22 instruction slots used +#endif + +const BYTE g_PS_SwizzleI2DArray[] = { + 68, 88, 66, 67, 212, 163, 121, 141, 10, 113, 132, 178, 58, 176, 145, 98, 43, 111, 211, + 61, 1, 0, 0, 0, 228, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 52, 1, + 0, 0, 188, 1, 0, 0, 240, 1, 0, 0, 104, 4, 0, 0, 82, 68, 69, 70, 248, + 0, 0, 0, 1, 0, 0, 0, 128, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 208, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 108, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 73, 50, 68, 65, 114, 114, 97, 121, 0, 83, 119, 105, + 122, 122, 108, 101, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 108, 0, + 0, 0, 1, 0, 0, 0, 152, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, + 192, 0, 0, 0, 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, + 99, 101, 115, 0, 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, + 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, + 48, 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, + 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, + 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, + 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, + 171, 171, 83, 72, 68, 82, 112, 2, 0, 0, 64, 0, 0, 0, 156, 0, 0, 0, 89, + 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, + 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, + 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, + 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, + 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, + 1, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, + 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, + 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, + 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, + 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, + 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 22, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h new file mode 100644 index 0000000000..fbce5942df --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h @@ -0,0 +1,132 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI2D texture sint4 2d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture2d (sint,sint,sint,sint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_PS_SwizzleI2D[] = { + 68, 88, 66, 67, 177, 45, 190, 185, 217, 208, 59, 28, 232, 250, 124, 179, 32, 246, 26, + 206, 1, 0, 0, 0, 152, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 48, 1, + 0, 0, 136, 1, 0, 0, 188, 1, 0, 0, 28, 4, 0, 0, 82, 68, 69, 70, 244, + 0, 0, 0, 1, 0, 0, 0, 124, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 204, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 73, 50, 68, 0, 83, 119, 105, 122, 122, 108, 101, 80, + 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 171, 103, 0, 0, 0, 1, 0, + 0, 0, 148, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 188, 0, 0, 0, + 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, 115, 0, + 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, + 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, + 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 88, 2, 0, 0, 64, 0, 0, 0, + 150, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, + 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, + 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, + 6, 0, 0, 0, 4, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, + 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, + 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, + 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, + 1, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, + 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, + 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, + 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, + 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, + 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 21, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei3dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei3dps.h new file mode 100644 index 0000000000..1ce3ce47c8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei3dps.h @@ -0,0 +1,135 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureI3D texture sint4 3d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET int xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture3d (sint,sint,sint,sint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_PS_SwizzleI3D[] = { + 68, 88, 66, 67, 239, 203, 72, 66, 58, 92, 169, 191, 239, 77, 187, 21, 109, 161, 64, + 95, 1, 0, 0, 0, 188, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 48, 1, + 0, 0, 184, 1, 0, 0, 236, 1, 0, 0, 64, 4, 0, 0, 82, 68, 69, 70, 244, + 0, 0, 0, 1, 0, 0, 0, 124, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 204, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 73, 51, 68, 0, 83, 119, 105, 122, 122, 108, 101, 80, + 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 171, 103, 0, 0, 0, 1, 0, + 0, 0, 148, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 188, 0, 0, 0, + 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, 115, 0, + 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, + 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, + 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, + 68, 82, 76, 2, 0, 0, 64, 0, 0, 0, 147, 0, 0, 0, 89, 0, 0, 4, 70, + 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, + 0, 0, 0, 0, 51, 51, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, + 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 61, + 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, 0, 0, 27, + 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, 1, 0, + 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, 0, 0, + 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, + 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, + 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 58, + 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, 16, 0, + 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 21, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h new file mode 100644 index 0000000000..d3d479f7b0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h @@ -0,0 +1,139 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI2DArray texture uint4 2darray t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint x +// TEXCOORD 0 xyz 2 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture2darray (uint,uint,uint,uint) t0 +dcl_input_ps_siv constant v1.x, rendertarget_array_index +dcl_input_ps linear v2.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v2.xyxx +ftoi r0.xy, r0.xyxx +mov r0.z, v1.x +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 22 instruction slots used +#endif + +const BYTE g_PS_SwizzleUI2DArray[] = { + 68, 88, 66, 67, 116, 247, 215, 129, 4, 49, 47, 120, 164, 87, 225, 112, 75, 76, 233, + 53, 1, 0, 0, 0, 228, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 52, 1, + 0, 0, 188, 1, 0, 0, 240, 1, 0, 0, 104, 4, 0, 0, 82, 68, 69, 70, 248, + 0, 0, 0, 1, 0, 0, 0, 128, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 208, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 109, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 85, 73, 50, 68, 65, 114, 114, 97, 121, 0, 83, 119, + 105, 122, 122, 108, 101, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 109, 0, + 0, 0, 1, 0, 0, 0, 152, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 176, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, + 192, 0, 0, 0, 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, + 99, 101, 115, 0, 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, + 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, + 48, 46, 49, 0, 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, + 0, 80, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 7, 3, 0, 0, 83, 86, 95, + 80, 79, 83, 73, 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, + 65, 82, 71, 69, 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, + 67, 79, 79, 82, 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, + 171, 171, 83, 72, 68, 82, 112, 2, 0, 0, 64, 0, 0, 0, 156, 0, 0, 0, 89, + 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 88, 64, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 100, 8, 0, 4, 18, 16, 16, + 0, 1, 0, 0, 0, 4, 0, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 2, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, + 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, 0, 0, 0, + 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, 16, 0, 0, + 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 2, 0, 0, 0, + 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 5, 66, 0, 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 1, 0, + 0, 0, 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, + 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, + 1, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, + 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, + 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, + 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, + 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, + 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 22, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h new file mode 100644 index 0000000000..b83bd117be --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h @@ -0,0 +1,132 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI2D texture uint4 2d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture2d (uint,uint,uint,uint) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftoi r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_PS_SwizzleUI2D[] = { + 68, 88, 66, 67, 5, 230, 100, 22, 104, 28, 143, 55, 98, 102, 32, 210, 129, 6, 68, + 183, 1, 0, 0, 0, 152, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 48, 1, + 0, 0, 136, 1, 0, 0, 188, 1, 0, 0, 28, 4, 0, 0, 82, 68, 69, 70, 244, + 0, 0, 0, 1, 0, 0, 0, 124, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 204, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 4, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 85, 73, 50, 68, 0, 83, 119, 105, 122, 122, 108, 101, + 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 104, 0, 0, 0, 1, 0, + 0, 0, 148, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 188, 0, 0, 0, + 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, 115, 0, + 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, + 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, + 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, + 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, + 82, 71, 69, 84, 0, 171, 171, 83, 72, 68, 82, 88, 2, 0, 0, 64, 0, 0, 0, + 150, 0, 0, 0, 89, 0, 0, 4, 70, 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 88, 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, + 0, 3, 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, + 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, + 6, 0, 0, 0, 4, 0, 0, 0, 61, 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, + 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 1, 0, 0, 0, 27, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, + 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, + 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 42, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, + 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, + 1, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, + 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, + 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, + 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, + 16, 0, 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, + 0, 0, 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, + 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, + 0, 58, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, + 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 21, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui3dps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui3dps.h new file mode 100644 index 0000000000..a7024e22db --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui3dps.h @@ -0,0 +1,135 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 10.1 +// +// +// Buffer Definitions: +// +// cbuffer SwizzleProperties +// { +// +// uint4 SwizzleIndices; // Offset: 0 Size: 16 +// +// } +// +// +// Resource Bindings: +// +// Name Type Format Dim HLSL Bind Count +// ------------------------------ ---------- ------- ----------- -------------- ------ +// TextureUI3D texture uint4 3d t0 1 +// SwizzleProperties cbuffer NA NA cb0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// SV_RENDERTARGETARRAYINDEX 0 x 1 RTINDEX uint +// TEXCOORD 0 xyz 2 NONE float xyz +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET uint xyzw +// +ps_4_0 +dcl_constantbuffer CB0[1], immediateIndexed +dcl_resource_texture3d (uint,uint,uint,uint) t0 +dcl_input_ps linear v2.xyz +dcl_output o0.xyzw +dcl_temps 1 +dcl_indexableTemp x0[6], 4 +resinfo_uint r0.xyzw, l(0), t0.xyzw +utof r0.xyz, r0.xyzx +mul r0.xyz, r0.xyzx, v2.xyzx +ftoi r0.xyz, r0.xyzx +mov r0.w, l(0) +ld r0.xyzw, r0.xyzw, t0.xyzw +mov x0[0].x, r0.x +mov x0[1].x, r0.y +mov x0[2].x, r0.z +mov x0[3].x, r0.w +mov x0[4].x, l(0) +mov x0[5].x, l(1) +mov r0.x, cb0[0].x +mov o0.x, x0[r0.x + 0].x +mov r0.x, cb0[0].y +mov o0.y, x0[r0.x + 0].x +mov r0.x, cb0[0].z +mov o0.z, x0[r0.x + 0].x +mov r0.x, cb0[0].w +mov o0.w, x0[r0.x + 0].x +ret +// Approximately 21 instruction slots used +#endif + +const BYTE g_PS_SwizzleUI3D[] = { + 68, 88, 66, 67, 234, 128, 119, 252, 97, 217, 113, 192, 202, 15, 92, 121, 106, 82, 46, + 102, 1, 0, 0, 0, 188, 4, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 48, 1, + 0, 0, 184, 1, 0, 0, 236, 1, 0, 0, 64, 4, 0, 0, 82, 68, 69, 70, 244, + 0, 0, 0, 1, 0, 0, 0, 124, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 0, 4, 255, 255, 0, 1, 0, 0, 204, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, + 0, 0, 13, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 84, 101, 120, 116, 117, 114, 101, 85, 73, 51, 68, 0, 83, 119, 105, 122, 122, 108, 101, + 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 0, 171, 171, 104, 0, 0, 0, 1, 0, + 0, 0, 148, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 188, 0, 0, 0, + 0, 0, 0, 0, 83, 119, 105, 122, 122, 108, 101, 73, 110, 100, 105, 99, 101, 115, 0, + 171, 1, 0, 19, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 105, + 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 49, 48, 46, 49, 0, + 73, 83, 71, 78, 128, 0, 0, 0, 3, 0, 0, 0, 8, 0, 0, 0, 80, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, + 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 2, 0, 0, 0, 7, 7, 0, 0, 83, 86, 95, 80, 79, 83, 73, + 84, 73, 79, 78, 0, 83, 86, 95, 82, 69, 78, 68, 69, 82, 84, 65, 82, 71, 69, + 84, 65, 82, 82, 65, 89, 73, 78, 68, 69, 88, 0, 84, 69, 88, 67, 79, 79, 82, + 68, 0, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171, 83, 72, + 68, 82, 76, 2, 0, 0, 64, 0, 0, 0, 147, 0, 0, 0, 89, 0, 0, 4, 70, + 142, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 88, 40, 0, 4, 0, 112, 16, 0, + 0, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 114, 16, 16, 0, 2, 0, 0, + 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, 0, + 0, 0, 105, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 61, + 16, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, + 0, 70, 2, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 0, 16, 0, 0, 0, + 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 70, 18, 16, 0, 2, 0, 0, 0, 27, + 0, 0, 5, 114, 0, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, + 54, 0, 0, 5, 130, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 45, 0, 0, 7, 242, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, + 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, + 18, 48, 32, 0, 0, 0, 0, 0, 1, 0, 0, 0, 26, 0, 16, 0, 0, 0, 0, + 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 2, 0, 0, 0, 42, 0, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 48, 32, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 48, 32, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 64, 0, 0, 1, 0, + 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 10, 128, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 18, 32, 16, 0, 0, 0, 0, 0, + 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 6, 18, 0, 16, 0, 0, 0, 0, 0, 26, 128, 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 54, 0, 0, 7, 34, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, + 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, + 0, 0, 0, 0, 42, 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 7, 66, 32, 16, 0, 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, + 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 18, 0, 16, 0, 0, 0, 0, 0, 58, + 128, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 7, 130, 32, 16, 0, + 0, 0, 0, 0, 10, 48, 32, 4, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, + 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 21, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp new file mode 100644 index 0000000000..a9dfec56b8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp @@ -0,0 +1,35 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Helper routines for the D3D11 texture format table. + +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +#include "libANGLE/renderer/load_functions_table.h" + +namespace rx +{ + +namespace d3d11 +{ + +const Format &Format::getSwizzleFormat(const Renderer11DeviceCaps &deviceCaps) const +{ + return (swizzleFormat == internalFormat ? *this : Format::Get(swizzleFormat, deviceCaps)); +} + +LoadFunctionMap Format::getLoadFunctions() const +{ + return GetLoadFunctionsMap(internalFormat, formatID); +} + +const angle::Format &Format::format() const +{ + return angle::Format::Get(formatID); +} + +} // namespace d3d11 + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h new file mode 100644 index 0000000000..1797476f62 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h @@ -0,0 +1,118 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// texture_format_table: +// Queries for full textureFormat information based on internalFormat +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATTABLE_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATTABLE_H_ + +#include <map> + +#include "common/angleutils.h" +#include "common/platform.h" +#include "libANGLE/renderer/Format.h" +#include "libANGLE/renderer/d3d/formatutilsD3D.h" +#include "libANGLE/renderer/renderer_utils.h" + +namespace rx +{ + +struct Renderer11DeviceCaps; + +namespace d3d11 +{ + +// For sized GL internal formats, there are several possible corresponding D3D11 formats depending +// on device capabilities. +// This structure allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and +// DSVs given a GL internal format. +struct Format final : private angle::NonCopyable +{ + inline constexpr Format(); + inline constexpr Format(GLenum internalFormat, + angle::FormatID formatID, + DXGI_FORMAT texFormat, + DXGI_FORMAT srvFormat, + DXGI_FORMAT uavFormat, + DXGI_FORMAT rtvFormat, + DXGI_FORMAT dsvFormat, + DXGI_FORMAT blitSRVFormat, + DXGI_FORMAT stencilSRVFormat, + DXGI_FORMAT typelessFormat, + GLenum swizzleFormat, + InitializeTextureDataFunction internalFormatInitializer); + + static const Format &Get(GLenum internalFormat, const Renderer11DeviceCaps &deviceCaps); + + const Format &getSwizzleFormat(const Renderer11DeviceCaps &deviceCaps) const; + LoadFunctionMap getLoadFunctions() const; + const angle::Format &format() const; + + GLenum internalFormat; + angle::FormatID formatID; + + DXGI_FORMAT texFormat; + DXGI_FORMAT srvFormat; + DXGI_FORMAT uavFormat; + DXGI_FORMAT rtvFormat; + DXGI_FORMAT dsvFormat; + + DXGI_FORMAT blitSRVFormat; + DXGI_FORMAT stencilSRVFormat; + DXGI_FORMAT typelessFormat; + + GLenum swizzleFormat; + + InitializeTextureDataFunction dataInitializerFunction; +}; + +constexpr Format::Format() + : internalFormat(GL_NONE), + formatID(angle::FormatID::NONE), + texFormat(DXGI_FORMAT_UNKNOWN), + srvFormat(DXGI_FORMAT_UNKNOWN), + uavFormat(DXGI_FORMAT_UNKNOWN), + rtvFormat(DXGI_FORMAT_UNKNOWN), + dsvFormat(DXGI_FORMAT_UNKNOWN), + blitSRVFormat(DXGI_FORMAT_UNKNOWN), + stencilSRVFormat(DXGI_FORMAT_UNKNOWN), + typelessFormat(DXGI_FORMAT_UNKNOWN), + swizzleFormat(GL_NONE), + dataInitializerFunction(nullptr) +{} + +constexpr Format::Format(GLenum internalFormat, + angle::FormatID formatID, + DXGI_FORMAT texFormat, + DXGI_FORMAT srvFormat, + DXGI_FORMAT uavFormat, + DXGI_FORMAT rtvFormat, + DXGI_FORMAT dsvFormat, + DXGI_FORMAT blitSRVFormat, + DXGI_FORMAT stencilSRVFormat, + DXGI_FORMAT typelessFormat, + GLenum swizzleFormat, + InitializeTextureDataFunction internalFormatInitializer) + : internalFormat(internalFormat), + formatID(formatID), + texFormat(texFormat), + srvFormat(srvFormat), + uavFormat(uavFormat), + rtvFormat(rtvFormat), + dsvFormat(dsvFormat), + blitSRVFormat(blitSRVFormat), + stencilSRVFormat(stencilSRVFormat), + typelessFormat(typelessFormat), + swizzleFormat(swizzleFormat), + dataInitializerFunction(internalFormatInitializer) +{} + +} // namespace d3d11 + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATTABLE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp new file mode 100644 index 0000000000..39d03a93fd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp @@ -0,0 +1,3269 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by gen_texture_format_table.py using data from texture_format_data.json +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// texture_format_table: +// Queries for full textureFormat information based in internalFormat +// + +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h" + +using namespace angle; + +namespace rx +{ + +namespace d3d11 +{ + +// static +const Format &Format::Get(GLenum internalFormat, const Renderer11DeviceCaps &deviceCaps) +{ + // clang-format off + switch (internalFormat) + { + case GL_ALPHA16F_EXT: + { + static constexpr Format info(GL_ALPHA16F_EXT, + angle::FormatID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16F, + nullptr); + return info; + } + case GL_ALPHA32F_EXT: + { + static constexpr Format info(GL_ALPHA32F_EXT, + angle::FormatID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32F, + nullptr); + return info; + } + case GL_ALPHA8_EXT: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_ALPHA8_EXT, + angle::FormatID::A8_UNORM, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_ALPHA8_EXT, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_BGR10_A2_ANGLEX: + { + static constexpr Format info(GL_BGR10_A2_ANGLEX, + angle::FormatID::B10G10R10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_BGR565_ANGLEX: + { + if (SupportsFormat(DXGI_FORMAT_B5G6R5_UNORM, deviceCaps)) + { + static constexpr Format info(GL_BGR565_ANGLEX, + angle::FormatID::B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_BGR565_ANGLEX, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_BGR5_A1_ANGLEX: + { + static constexpr Format info(GL_BGR5_A1_ANGLEX, + angle::FormatID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_TYPELESS, + GL_BGRA8_EXT, + nullptr); + return info; + } + case GL_BGRA4_ANGLEX: + { + static constexpr Format info(GL_BGRA4_ANGLEX, + angle::FormatID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_TYPELESS, + GL_BGRA8_EXT, + nullptr); + return info; + } + case GL_BGRA8_EXT: + { + static constexpr Format info(GL_BGRA8_EXT, + angle::FormatID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_TYPELESS, + GL_BGRA8_EXT, + nullptr); + return info; + } + case GL_BGRA8_SRGB_ANGLEX: + { + static constexpr Format info(GL_BGRA8_SRGB_ANGLEX, + angle::FormatID::B8G8R8A8_UNORM_SRGB, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_TYPELESS, + GL_BGRA8_SRGB_ANGLEX, + nullptr); + return info; + } + case GL_BGRX8_ANGLEX: + { + if (OnlyFL11_1Plus(deviceCaps)) + { + static constexpr Format info(GL_BGRX8_ANGLEX, + angle::FormatID::B8G8R8X8_UNORM, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8X8_TYPELESS, + GL_BGRX8_ANGLEX, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_BGRX8_ANGLEX, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_COMPRESSED_R11_EAC: + { + static constexpr Format info(GL_COMPRESSED_R11_EAC, + angle::FormatID::R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_COMPRESSED_RED_GREEN_RGTC2_EXT: + { + static constexpr Format info(GL_COMPRESSED_RED_GREEN_RGTC2_EXT, + angle::FormatID::BC5_RG_UNORM_BLOCK, + DXGI_FORMAT_BC5_UNORM, + DXGI_FORMAT_BC5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RED_RGTC1_EXT: + { + static constexpr Format info(GL_COMPRESSED_RED_RGTC1_EXT, + angle::FormatID::BC4_RED_UNORM_BLOCK, + DXGI_FORMAT_BC4_UNORM, + DXGI_FORMAT_BC4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RG11_EAC: + { + static constexpr Format info(GL_COMPRESSED_RG11_EAC, + angle::FormatID::R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_COMPRESSED_RGB8_ETC2: + { + static constexpr Format info(GL_COMPRESSED_RGB8_ETC2, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, + angle::FormatID::BC1_RGB_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: + { + static constexpr Format info(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, + angle::FormatID::BC1_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA8_ETC2_EAC: + { + static constexpr Format info(GL_COMPRESSED_RGBA8_ETC2_EAC, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_3x3x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_4x3x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_4x4x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_4x4x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_5x4x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_5x5x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_5x5x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_6x5x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_6x6x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_6x6x6_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: + { + static constexpr Format info(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT: + { + static constexpr Format info(GL_COMPRESSED_RGBA_BPTC_UNORM_EXT, + angle::FormatID::BC7_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC7_UNORM, + DXGI_FORMAT_BC7_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC7_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: + { + static constexpr Format info(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: + { + static constexpr Format info(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + { + static constexpr Format info(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, + angle::FormatID::BC1_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, + angle::FormatID::BC2_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC2_UNORM, + DXGI_FORMAT_BC2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, + angle::FormatID::BC3_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC3_UNORM, + DXGI_FORMAT_BC3_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC3_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: + { + static constexpr Format info(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, + angle::FormatID::BC6H_RGB_SFLOAT_BLOCK, + DXGI_FORMAT_BC6H_SF16, + DXGI_FORMAT_BC6H_SF16, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC6H_SF16, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: + { + static constexpr Format info(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, + angle::FormatID::BC6H_RGB_UFLOAT_BLOCK, + DXGI_FORMAT_BC6H_UF16, + DXGI_FORMAT_BC6H_UF16, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC6H_UF16, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + case GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG: + { + static constexpr Format info(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG: + { + static constexpr Format info(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + { + static constexpr Format info(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, + angle::FormatID::BC1_RGB_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SIGNED_R11_EAC: + { + static constexpr Format info(GL_COMPRESSED_SIGNED_R11_EAC, + angle::FormatID::R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16_SNORM_EXT, + nullptr); + return info; + } + case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: + { + static constexpr Format info(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, + angle::FormatID::BC5_RG_SNORM_BLOCK, + DXGI_FORMAT_BC5_SNORM, + DXGI_FORMAT_BC5_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC5_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8_SNORM, + nullptr); + return info; + } + case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, + angle::FormatID::BC4_RED_SNORM_BLOCK, + DXGI_FORMAT_BC4_SNORM, + DXGI_FORMAT_BC4_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC4_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8_SNORM, + nullptr); + return info; + } + case GL_COMPRESSED_SIGNED_RG11_EAC: + { + static constexpr Format info(GL_COMPRESSED_SIGNED_RG11_EAC, + angle::FormatID::R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16_SNORM_EXT, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, + angle::FormatID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_SRGB8_ALPHA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_ETC2: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_ETC2, + angle::FormatID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_SRGB8_ALPHA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, + angle::FormatID::BC1_RGB_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, + angle::FormatID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_SRGB8_ALPHA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE: + { + static constexpr Format info(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, + angle::FormatID::BC1_RGBA_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, + angle::FormatID::BC7_RGBA_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC7_UNORM_SRGB, + DXGI_FORMAT_BC7_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC7_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_SRGB8_ALPHA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, + angle::FormatID::BC1_RGBA_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, + angle::FormatID::BC2_RGBA_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC2_UNORM_SRGB, + DXGI_FORMAT_BC2_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC2_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, + angle::FormatID::BC3_RGBA_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC3_UNORM_SRGB, + DXGI_FORMAT_BC3_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC3_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: + { + static constexpr Format info(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, + angle::FormatID::BC1_RGB_UNORM_SRGB_BLOCK, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_DEPTH24_STENCIL8: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_DEPTH24_STENCIL8, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_X24_TYPELESS_G8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_DEPTH24_STENCIL8, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + } + case GL_DEPTH32F_STENCIL8: + { + static constexpr Format info(GL_DEPTH32F_STENCIL8, + angle::FormatID::D32_FLOAT_S8X24_UINT, + DXGI_FORMAT_R32G8X24_TYPELESS, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D32_FLOAT_S8X24_UINT, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + case GL_DEPTH_COMPONENT16: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_DEPTH_COMPONENT16, + angle::FormatID::D16_UNORM, + DXGI_FORMAT_R16_TYPELESS, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA16_EXT, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_DEPTH_COMPONENT16, + angle::FormatID::D16_UNORM, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA16_EXT, + nullptr); + return info; + } + } + case GL_DEPTH_COMPONENT24: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_DEPTH_COMPONENT24, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_X24_TYPELESS_G8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_DEPTH_COMPONENT24, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + } + case GL_DEPTH_COMPONENT32F: + { + static constexpr Format info(GL_DEPTH_COMPONENT32F, + angle::FormatID::D32_FLOAT, + DXGI_FORMAT_R32_TYPELESS, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + case GL_DEPTH_COMPONENT32_OES: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_DEPTH_COMPONENT32_OES, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_X24_TYPELESS_G8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_DEPTH_COMPONENT32_OES, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + } + case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: + { + static constexpr Format info(GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, + angle::FormatID::BC1_RGB_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + case GL_ETC1_RGB8_OES: + { + static constexpr Format info(GL_ETC1_RGB8_OES, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_G8_B8R8_2PLANE_420_UNORM_ANGLE: + { + static constexpr Format info(GL_G8_B8R8_2PLANE_420_UNORM_ANGLE, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_G8_B8_R8_3PLANE_420_UNORM_ANGLE: + { + static constexpr Format info(GL_G8_B8_R8_3PLANE_420_UNORM_ANGLE, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_LUMINANCE16F_EXT: + { + static constexpr Format info(GL_LUMINANCE16F_EXT, + angle::FormatID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16F, + Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>); + return info; + } + case GL_LUMINANCE32F_EXT: + { + static constexpr Format info(GL_LUMINANCE32F_EXT, + angle::FormatID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32F, + Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>); + return info; + } + case GL_LUMINANCE8_ALPHA8_EXT: + { + static constexpr Format info(GL_LUMINANCE8_ALPHA8_EXT, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_LUMINANCE8_EXT: + { + static constexpr Format info(GL_LUMINANCE8_EXT, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_LUMINANCE_ALPHA16F_EXT: + { + static constexpr Format info(GL_LUMINANCE_ALPHA16F_EXT, + angle::FormatID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16F, + nullptr); + return info; + } + case GL_LUMINANCE_ALPHA32F_EXT: + { + static constexpr Format info(GL_LUMINANCE_ALPHA32F_EXT, + angle::FormatID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32F, + nullptr); + return info; + } + case GL_NONE: + { + static constexpr Format info(GL_NONE, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE4_R5_G6_B5_OES: + { + static constexpr Format info(GL_PALETTE4_R5_G6_B5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE4_RGB5_A1_OES: + { + static constexpr Format info(GL_PALETTE4_RGB5_A1_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE4_RGB8_OES: + { + static constexpr Format info(GL_PALETTE4_RGB8_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE4_RGBA4_OES: + { + static constexpr Format info(GL_PALETTE4_RGBA4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE4_RGBA8_OES: + { + static constexpr Format info(GL_PALETTE4_RGBA8_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE8_R5_G6_B5_OES: + { + static constexpr Format info(GL_PALETTE8_R5_G6_B5_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE8_RGB5_A1_OES: + { + static constexpr Format info(GL_PALETTE8_RGB5_A1_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE8_RGB8_OES: + { + static constexpr Format info(GL_PALETTE8_RGB8_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE8_RGBA4_OES: + { + static constexpr Format info(GL_PALETTE8_RGBA4_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_PALETTE8_RGBA8_OES: + { + static constexpr Format info(GL_PALETTE8_RGBA8_OES, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_R11F_G11F_B10F: + { + static constexpr Format info(GL_R11F_G11F_B10F, + angle::FormatID::R11G11B10_FLOAT, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA16F_EXT, + nullptr); + return info; + } + case GL_R16F: + { + static constexpr Format info(GL_R16F, + angle::FormatID::R16_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16F_EXT, + nullptr); + return info; + } + case GL_R16I: + { + static constexpr Format info(GL_R16I, + angle::FormatID::R16_SINT, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_R16UI: + { + static constexpr Format info(GL_R16UI, + angle::FormatID::R16_UINT, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_R16_EXT: + { + static constexpr Format info(GL_R16_EXT, + angle::FormatID::R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_R16_SNORM_EXT: + { + static constexpr Format info(GL_R16_SNORM_EXT, + angle::FormatID::R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_TYPELESS, + GL_RGBA16_SNORM_EXT, + nullptr); + return info; + } + case GL_R32F: + { + static constexpr Format info(GL_R32F, + angle::FormatID::R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_TYPELESS, + GL_RGBA32F, + nullptr); + return info; + } + case GL_R32I: + { + static constexpr Format info(GL_R32I, + angle::FormatID::R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_TYPELESS, + GL_RGBA32I, + nullptr); + return info; + } + case GL_R32UI: + { + static constexpr Format info(GL_R32UI, + angle::FormatID::R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_TYPELESS, + GL_RGBA32I, + nullptr); + return info; + } + case GL_R8: + { + static constexpr Format info(GL_R8, + angle::FormatID::R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_R8I: + { + static constexpr Format info(GL_R8I, + angle::FormatID::R8_SINT, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_TYPELESS, + GL_RGBA8I, + nullptr); + return info; + } + case GL_R8UI: + { + static constexpr Format info(GL_R8UI, + angle::FormatID::R8_UINT, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_TYPELESS, + GL_RGBA8I, + nullptr); + return info; + } + case GL_R8_SNORM: + { + static constexpr Format info(GL_R8_SNORM, + angle::FormatID::R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_TYPELESS, + GL_RGBA8_SNORM, + nullptr); + return info; + } + case GL_RG16F: + { + static constexpr Format info(GL_RG16F, + angle::FormatID::R16G16_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16F_EXT, + nullptr); + return info; + } + case GL_RG16I: + { + static constexpr Format info(GL_RG16I, + angle::FormatID::R16G16_SINT, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_RG16UI: + { + static constexpr Format info(GL_RG16UI, + angle::FormatID::R16G16_UINT, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_RG16_EXT: + { + static constexpr Format info(GL_RG16_EXT, + angle::FormatID::R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_RG16_SNORM_EXT: + { + static constexpr Format info(GL_RG16_SNORM_EXT, + angle::FormatID::R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_TYPELESS, + GL_RGBA16_SNORM_EXT, + nullptr); + return info; + } + case GL_RG32F: + { + static constexpr Format info(GL_RG32F, + angle::FormatID::R32G32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_TYPELESS, + GL_RGBA32F, + nullptr); + return info; + } + case GL_RG32I: + { + static constexpr Format info(GL_RG32I, + angle::FormatID::R32G32_SINT, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_TYPELESS, + GL_RGBA32I, + nullptr); + return info; + } + case GL_RG32UI: + { + static constexpr Format info(GL_RG32UI, + angle::FormatID::R32G32_UINT, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_TYPELESS, + GL_RGBA32I, + nullptr); + return info; + } + case GL_RG8: + { + static constexpr Format info(GL_RG8, + angle::FormatID::R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_RG8I: + { + static constexpr Format info(GL_RG8I, + angle::FormatID::R8G8_SINT, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_TYPELESS, + GL_RGBA8I, + nullptr); + return info; + } + case GL_RG8UI: + { + static constexpr Format info(GL_RG8UI, + angle::FormatID::R8G8_UINT, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_TYPELESS, + GL_RGBA8I, + nullptr); + return info; + } + case GL_RG8_SNORM: + { + static constexpr Format info(GL_RG8_SNORM, + angle::FormatID::R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_TYPELESS, + GL_RGBA8_SNORM, + nullptr); + return info; + } + case GL_RGB: + { + static constexpr Format info(GL_RGB, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_RGB10_A2: + { + static constexpr Format info(GL_RGB10_A2, + angle::FormatID::R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_RGB10_A2UI: + { + static constexpr Format info(GL_RGB10_A2UI, + angle::FormatID::R10G10B10A2_UINT, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_RGB10_UNORM_ANGLEX: + { + static constexpr Format info(GL_RGB10_UNORM_ANGLEX, + angle::FormatID::R10G10B10X2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_RGB16F: + { + static constexpr Format info(GL_RGB16F, + angle::FormatID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16F, + Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>); + return info; + } + case GL_RGB16I: + { + static constexpr Format info(GL_RGB16I, + angle::FormatID::R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16I, + Initialize4ComponentData<GLshort, 0x0000, 0x0000, 0x0000, 0x0001>); + return info; + } + case GL_RGB16UI: + { + static constexpr Format info(GL_RGB16UI, + angle::FormatID::R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16UI, + Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x0001>); + return info; + } + case GL_RGB16_EXT: + { + static constexpr Format info(GL_RGB16_EXT, + angle::FormatID::R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16_EXT, + Initialize4ComponentData<GLubyte, 0x0000, 0x0000, 0x0000, 0xFFFF>); + return info; + } + case GL_RGB16_SNORM_EXT: + { + static constexpr Format info(GL_RGB16_SNORM_EXT, + angle::FormatID::R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16_SNORM_EXT, + Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x7FFF>); + return info; + } + case GL_RGB32F: + { + static constexpr Format info(GL_RGB32F, + angle::FormatID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32F, + Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>); + return info; + } + case GL_RGB32I: + { + static constexpr Format info(GL_RGB32I, + angle::FormatID::R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32I, + Initialize4ComponentData<GLint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>); + return info; + } + case GL_RGB32UI: + { + static constexpr Format info(GL_RGB32UI, + angle::FormatID::R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32UI, + Initialize4ComponentData<GLuint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>); + return info; + } + case GL_RGB565: + { + if (SupportsFormat(DXGI_FORMAT_B5G6R5_UNORM, deviceCaps)) + { + static constexpr Format info(GL_RGB565, + angle::FormatID::B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_RGB565, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + } + case GL_RGB5_A1: + { + if (SupportsFormat(DXGI_FORMAT_B5G5R5A1_UNORM, deviceCaps)) + { + static constexpr Format info(GL_RGB5_A1, + angle::FormatID::B5G5R5A1_UNORM, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA8, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_RGB5_A1, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_RGB8: + { + static constexpr Format info(GL_RGB8, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_RGB8I: + { + static constexpr Format info(GL_RGB8I, + angle::FormatID::R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8I, + Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x01>); + return info; + } + case GL_RGB8UI: + { + static constexpr Format info(GL_RGB8UI, + angle::FormatID::R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8UI, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0x01>); + return info; + } + case GL_RGB8_SNORM: + { + static constexpr Format info(GL_RGB8_SNORM, + angle::FormatID::R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8_SNORM, + Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x7F>); + return info; + } + case GL_RGB9_E5: + { + static constexpr Format info(GL_RGB9_E5, + angle::FormatID::R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA16F_EXT, + nullptr); + return info; + } + case GL_RGBA: + { + static constexpr Format info(GL_RGBA, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_RGBA16F: + { + static constexpr Format info(GL_RGBA16F, + angle::FormatID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16F, + nullptr); + return info; + } + case GL_RGBA16I: + { + static constexpr Format info(GL_RGBA16I, + angle::FormatID::R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16I, + nullptr); + return info; + } + case GL_RGBA16UI: + { + static constexpr Format info(GL_RGBA16UI, + angle::FormatID::R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16UI, + nullptr); + return info; + } + case GL_RGBA16_EXT: + { + static constexpr Format info(GL_RGBA16_EXT, + angle::FormatID::R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16_EXT, + nullptr); + return info; + } + case GL_RGBA16_SNORM_EXT: + { + static constexpr Format info(GL_RGBA16_SNORM_EXT, + angle::FormatID::R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_TYPELESS, + GL_RGBA16_SNORM_EXT, + nullptr); + return info; + } + case GL_RGBA32F: + { + static constexpr Format info(GL_RGBA32F, + angle::FormatID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32F, + nullptr); + return info; + } + case GL_RGBA32I: + { + static constexpr Format info(GL_RGBA32I, + angle::FormatID::R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32I, + nullptr); + return info; + } + case GL_RGBA32UI: + { + static constexpr Format info(GL_RGBA32UI, + angle::FormatID::R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_TYPELESS, + GL_RGBA32UI, + nullptr); + return info; + } + case GL_RGBA4: + { + if (SupportsFormat(DXGI_FORMAT_B4G4R4A4_UNORM, deviceCaps)) + { + static constexpr Format info(GL_RGBA4, + angle::FormatID::B4G4R4A4_UNORM, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA4, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_RGBA4, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_RGBA8: + { + static constexpr Format info(GL_RGBA8, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + case GL_RGBA8I: + { + static constexpr Format info(GL_RGBA8I, + angle::FormatID::R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8I, + nullptr); + return info; + } + case GL_RGBA8UI: + { + static constexpr Format info(GL_RGBA8UI, + angle::FormatID::R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8UI, + nullptr); + return info; + } + case GL_RGBA8_SNORM: + { + static constexpr Format info(GL_RGBA8_SNORM, + angle::FormatID::R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8_SNORM, + nullptr); + return info; + } + case GL_RGBX8_ANGLE: + { + if (OnlyFL11_1Plus(deviceCaps)) + { + static constexpr Format info(GL_RGBX8_ANGLE, + angle::FormatID::R8G8B8X8_UNORM, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8X8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBX8_ANGLE, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_RGBX8_ANGLE, + angle::FormatID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_RGBA8, + nullptr); + return info; + } + } + case GL_SR8_EXT: + { + static constexpr Format info(GL_SR8_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_SRG8_EXT: + { + static constexpr Format info(GL_SRG8_EXT, + angle::FormatID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr); + return info; + } + case GL_SRGB8: + { + static constexpr Format info(GL_SRGB8, + angle::FormatID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_SRGB8_ALPHA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); + return info; + } + case GL_SRGB8_ALPHA8: + { + static constexpr Format info(GL_SRGB8_ALPHA8, + angle::FormatID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_TYPELESS, + GL_SRGB8_ALPHA8, + nullptr); + return info; + } + case GL_STENCIL_INDEX8: + { + if (OnlyFL10Plus(deviceCaps)) + { + static constexpr Format info(GL_STENCIL_INDEX8, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_X24_TYPELESS_G8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + else + { + static constexpr Format info(GL_STENCIL_INDEX8, + angle::FormatID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr); + return info; + } + } + + default: + break; + } + // clang-format on + + UNREACHABLE(); + static constexpr Format defaultInfo; + return defaultInfo; +} + +} // namespace d3d11 + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h new file mode 100644 index 0000000000..f46f769182 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h @@ -0,0 +1,90 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Helper routines for the D3D11 texture format table. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ + +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +namespace d3d11 +{ + +using FormatSupportFunction = bool (*)(const Renderer11DeviceCaps &); + +inline bool OnlyFL11_1Plus(const Renderer11DeviceCaps &deviceCaps) +{ + return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_11_1); +} + +inline bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps) +{ + return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0); +} + +inline bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps) +{ + return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3); +} + +inline bool SupportsFormat(DXGI_FORMAT format, const Renderer11DeviceCaps &deviceCaps) +{ + // Must support texture, SRV and RTV support + UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE | + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP | + D3D11_FORMAT_SUPPORT_RENDER_TARGET; + UINT minimumRequiredSamples = 0; + + if (d3d11_gl::GetMaximumClientVersion(deviceCaps).major > 2) + { + mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D; + + // RGBA4, RGB5A1 and RGB565 are all required multisampled renderbuffer formats in ES3 and + // need to support a minimum of 4 samples. + minimumRequiredSamples = 4; + } + + bool fullSupport = false; + if (format == DXGI_FORMAT_B5G6R5_UNORM) + { + // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but + // check anyway. + mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN; + fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport) && + deviceCaps.B5G6R5maxSamples >= minimumRequiredSamples; + } + else if (format == DXGI_FORMAT_B4G4R4A4_UNORM) + { + fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport) && + deviceCaps.B4G4R4A4maxSamples >= minimumRequiredSamples; + } + else if (format == DXGI_FORMAT_B5G5R5A1_UNORM) + { + fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport) && + deviceCaps.B5G5R5A1maxSamples >= minimumRequiredSamples; + } + else + { + UNREACHABLE(); + return false; + } + + // This means that ANGLE would like to use the entry in the map if the inputted DXGI format + // *IS* supported. + // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if + // DXGI_FORMAT_B5G5R5A1 is supported. + // In this case, we should only return 'true' if the format *IS* supported. + return fullSupport; +} + +} // namespace d3d11 + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.cpp new file mode 100644 index 0000000000..722510a482 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.cpp @@ -0,0 +1,218 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindow11Win32.cpp: Implementation of NativeWindow11 using win32 window APIs. + +#include "libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.h" +#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" + +#include "common/debug.h" + +// This header must be included before dcomp.h. +#include <initguid.h> + +#include <dcomp.h> + +namespace rx +{ + +NativeWindow11Win32::NativeWindow11Win32(EGLNativeWindowType window, + bool hasAlpha, + bool directComposition) + : NativeWindow11(window), + mDirectComposition(directComposition), + mHasAlpha(hasAlpha), + mDevice(nullptr), + mCompositionTarget(nullptr), + mVisual(nullptr) +{} + +NativeWindow11Win32::~NativeWindow11Win32() +{ + SafeRelease(mCompositionTarget); + SafeRelease(mDevice); + SafeRelease(mVisual); +} + +bool NativeWindow11Win32::initialize() +{ + return true; +} + +bool NativeWindow11Win32::getClientRect(LPRECT rect) const +{ + return GetClientRect(getNativeWindow(), rect) == TRUE; +} + +bool NativeWindow11Win32::isIconic() const +{ + return IsIconic(getNativeWindow()) == TRUE; +} + +HRESULT NativeWindow11Win32::createSwapChain(ID3D11Device *device, + IDXGIFactory *factory, + DXGI_FORMAT format, + UINT width, + UINT height, + UINT samples, + IDXGISwapChain **swapChain) +{ + if (device == nullptr || factory == nullptr || swapChain == nullptr || width == 0 || + height == 0) + { + return E_INVALIDARG; + } + + if (mDirectComposition) + { + HMODULE dcomp = ::GetModuleHandle(TEXT("dcomp.dll")); + if (!dcomp) + { + return E_INVALIDARG; + } + + typedef HRESULT(WINAPI * PFN_DCOMPOSITION_CREATE_DEVICE)( + IDXGIDevice * dxgiDevice, REFIID iid, void **dcompositionDevice); + PFN_DCOMPOSITION_CREATE_DEVICE createDComp = + reinterpret_cast<PFN_DCOMPOSITION_CREATE_DEVICE>( + GetProcAddress(dcomp, "DCompositionCreateDevice")); + if (!createDComp) + { + return E_INVALIDARG; + } + + if (!mDevice) + { + IDXGIDevice *dxgiDevice = d3d11::DynamicCastComObject<IDXGIDevice>(device); + HRESULT result = createDComp(dxgiDevice, __uuidof(IDCompositionDevice), + reinterpret_cast<void **>(&mDevice)); + SafeRelease(dxgiDevice); + + if (FAILED(result)) + { + return result; + } + } + + if (!mCompositionTarget) + { + HRESULT result = + mDevice->CreateTargetForHwnd(getNativeWindow(), TRUE, &mCompositionTarget); + if (FAILED(result)) + { + return result; + } + } + + if (!mVisual) + { + HRESULT result = mDevice->CreateVisual(&mVisual); + if (FAILED(result)) + { + return result; + } + } + + IDXGIFactory2 *factory2 = d3d11::DynamicCastComObject<IDXGIFactory2>(factory); + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {}; + swapChainDesc.Width = width; + swapChainDesc.Height = height; + swapChainDesc.Format = format; + swapChainDesc.Stereo = FALSE; + swapChainDesc.SampleDesc.Count = 1; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.BufferUsage = + DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_SHADER_INPUT; + swapChainDesc.BufferCount = 2; + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + swapChainDesc.AlphaMode = + mHasAlpha ? DXGI_ALPHA_MODE_PREMULTIPLIED : DXGI_ALPHA_MODE_IGNORE; + swapChainDesc.Flags = 0; + IDXGISwapChain1 *swapChain1 = nullptr; + HRESULT result = + factory2->CreateSwapChainForComposition(device, &swapChainDesc, nullptr, &swapChain1); + if (SUCCEEDED(result)) + { + *swapChain = static_cast<IDXGISwapChain *>(swapChain1); + } + mVisual->SetContent(swapChain1); + mCompositionTarget->SetRoot(mVisual); + SafeRelease(factory2); + return result; + } + + // Use IDXGIFactory2::CreateSwapChainForHwnd if DXGI 1.2 is available to create a + // DXGI_SWAP_EFFECT_SEQUENTIAL swap chain. + IDXGIFactory2 *factory2 = d3d11::DynamicCastComObject<IDXGIFactory2>(factory); + if (factory2 != nullptr) + { + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {}; + swapChainDesc.Width = width; + swapChainDesc.Height = height; + swapChainDesc.Format = format; + swapChainDesc.Stereo = FALSE; + swapChainDesc.SampleDesc.Count = samples; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.BufferUsage = + DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER; + swapChainDesc.BufferCount = 1; + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; + swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED; + swapChainDesc.Flags = 0; + IDXGISwapChain1 *swapChain1 = nullptr; + HRESULT result = factory2->CreateSwapChainForHwnd(device, getNativeWindow(), &swapChainDesc, + nullptr, nullptr, &swapChain1); + if (SUCCEEDED(result)) + { + factory2->MakeWindowAssociation(getNativeWindow(), DXGI_MWA_NO_ALT_ENTER); + *swapChain = static_cast<IDXGISwapChain *>(swapChain1); + } + SafeRelease(factory2); + return result; + } + + DXGI_SWAP_CHAIN_DESC swapChainDesc = {}; + swapChainDesc.BufferCount = 1; + swapChainDesc.BufferDesc.Format = format; + swapChainDesc.BufferDesc.Width = width; + swapChainDesc.BufferDesc.Height = height; + swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; + swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; + swapChainDesc.BufferUsage = + DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER; + swapChainDesc.Flags = 0; + swapChainDesc.OutputWindow = getNativeWindow(); + swapChainDesc.SampleDesc.Count = samples; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.Windowed = TRUE; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + + HRESULT result = factory->CreateSwapChain(device, &swapChainDesc, swapChain); + if (SUCCEEDED(result)) + { + factory->MakeWindowAssociation(getNativeWindow(), DXGI_MWA_NO_ALT_ENTER); + } + return result; +} + +void NativeWindow11Win32::commitChange() +{ + if (mDevice) + { + mDevice->Commit(); + } +} + +// static +bool NativeWindow11Win32::IsValidNativeWindow(EGLNativeWindowType window) +{ + return IsWindow(window) == TRUE; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.h new file mode 100644 index 0000000000..f67cfc73a8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d11/win32/NativeWindow11Win32.h @@ -0,0 +1,53 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindow11Win32.h: Implementation of NativeWindow11 using win32 window APIs. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_WIN32_NATIVEWINDOW11WIN32_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_WIN32_NATIVEWINDOW11WIN32_H_ + +#include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h" + +typedef interface IDCompositionDevice IDCompositionDevice; +typedef interface IDCompositionTarget IDCompositionTarget; +typedef interface IDCompositionVisual IDCompositionVisual; + +namespace rx +{ + +class NativeWindow11Win32 : public NativeWindow11 +{ + public: + NativeWindow11Win32(EGLNativeWindowType window, bool hasAlpha, bool directComposition); + ~NativeWindow11Win32() override; + + bool initialize() override; + bool getClientRect(LPRECT rect) const override; + bool isIconic() const override; + + HRESULT createSwapChain(ID3D11Device *device, + IDXGIFactory *factory, + DXGI_FORMAT format, + UINT width, + UINT height, + UINT samples, + IDXGISwapChain **swapChain) override; + + void commitChange() override; + + static bool IsValidNativeWindow(EGLNativeWindowType window); + + private: + bool mDirectComposition; + bool mHasAlpha; + IDCompositionDevice *mDevice; + IDCompositionTarget *mCompositionTarget; + IDCompositionVisual *mVisual; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_WIN32_NATIVEWINDOW11WIN32_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp new file mode 100644 index 0000000000..429159b4cb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp @@ -0,0 +1,760 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Blit9.cpp: Surface copy utility class. + +#include "libANGLE/renderer/d3d/d3d9/Blit9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace +{ +// Precompiled shaders +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskpremultps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskunmultps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/luminancepremultps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceunmultps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/passthroughps.h" +#include "libANGLE/renderer/d3d/d3d9/shaders/compiled/standardvs.h" + +const BYTE *const g_shaderCode[] = { + g_vs20_standardvs, + g_ps20_passthroughps, + g_ps20_luminanceps, + g_ps20_luminancepremultps, + g_ps20_luminanceunmultps, + g_ps20_componentmaskps, + g_ps20_componentmaskpremultps, + g_ps20_componentmaskunmultps, +}; + +const size_t g_shaderSize[] = { + sizeof(g_vs20_standardvs), + sizeof(g_ps20_passthroughps), + sizeof(g_ps20_luminanceps), + sizeof(g_ps20_luminancepremultps), + sizeof(g_ps20_luminanceunmultps), + sizeof(g_ps20_componentmaskps), + sizeof(g_ps20_componentmaskpremultps), + sizeof(g_ps20_componentmaskunmultps), +}; +} // namespace + +namespace rx +{ + +Blit9::Blit9(Renderer9 *renderer) + : mRenderer(renderer), + mGeometryLoaded(false), + mQuadVertexBuffer(nullptr), + mQuadVertexDeclaration(nullptr), + mSavedStateBlock(nullptr), + mSavedRenderTarget(nullptr), + mSavedDepthStencil(nullptr) +{ + memset(mCompiledShaders, 0, sizeof(mCompiledShaders)); +} + +Blit9::~Blit9() +{ + SafeRelease(mSavedStateBlock); + SafeRelease(mQuadVertexBuffer); + SafeRelease(mQuadVertexDeclaration); + + for (int i = 0; i < SHADER_COUNT; i++) + { + SafeRelease(mCompiledShaders[i]); + } +} + +angle::Result Blit9::initialize(Context9 *context9) +{ + if (mGeometryLoaded) + { + return angle::Result::Continue; + } + + static const float quad[] = {-1, -1, -1, 1, 1, -1, 1, 1}; + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + HRESULT result = device->CreateVertexBuffer(sizeof(quad), D3DUSAGE_WRITEONLY, 0, + D3DPOOL_DEFAULT, &mQuadVertexBuffer, nullptr); + + ANGLE_TRY_HR(context9, result, "Failed to create internal blit vertex shader"); + + void *lockPtr = nullptr; + result = mQuadVertexBuffer->Lock(0, 0, &lockPtr, 0); + + ANGLE_TRY_HR(context9, result, "Failed to lock internal blit vertex shader"); + ASSERT(lockPtr); + + memcpy(lockPtr, quad, sizeof(quad)); + mQuadVertexBuffer->Unlock(); + + static const D3DVERTEXELEMENT9 elements[] = { + {0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, D3DDECL_END()}; + + result = device->CreateVertexDeclaration(elements, &mQuadVertexDeclaration); + ANGLE_TRY_HR(context9, result, "Failed to create internal blit vertex shader declaration"); + + mGeometryLoaded = true; + return angle::Result::Continue; +} + +template <class D3DShaderType> +angle::Result Blit9::setShader(Context9 *context9, + ShaderId source, + const char *profile, + angle::Result (Renderer9::*createShader)(d3d::Context *, + const DWORD *, + size_t length, + D3DShaderType **outShader), + HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType *)) +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + D3DShaderType *shader = nullptr; + + if (mCompiledShaders[source] != nullptr) + { + shader = static_cast<D3DShaderType *>(mCompiledShaders[source]); + } + else + { + const BYTE *shaderCode = g_shaderCode[source]; + size_t shaderSize = g_shaderSize[source]; + ANGLE_TRY((mRenderer->*createShader)(context9, reinterpret_cast<const DWORD *>(shaderCode), + shaderSize, &shader)); + mCompiledShaders[source] = shader; + } + + HRESULT hr = (device->*setShader)(shader); + ANGLE_TRY_HR(context9, hr, "Failed to set shader for blit operation"); + return angle::Result::Continue; +} + +angle::Result Blit9::setVertexShader(Context9 *context9, ShaderId shader) +{ + return setShader<IDirect3DVertexShader9>(context9, shader, "vs_2_0", + &Renderer9::createVertexShader, + &IDirect3DDevice9::SetVertexShader); +} + +angle::Result Blit9::setPixelShader(Context9 *context9, ShaderId shader) +{ + return setShader<IDirect3DPixelShader9>(context9, shader, "ps_2_0", + &Renderer9::createPixelShader, + &IDirect3DDevice9::SetPixelShader); +} + +RECT Blit9::getSurfaceRect(IDirect3DSurface9 *surface) const +{ + D3DSURFACE_DESC desc; + surface->GetDesc(&desc); + + RECT rect; + rect.left = 0; + rect.top = 0; + rect.right = desc.Width; + rect.bottom = desc.Height; + + return rect; +} + +gl::Extents Blit9::getSurfaceSize(IDirect3DSurface9 *surface) const +{ + D3DSURFACE_DESC desc; + surface->GetDesc(&desc); + + return gl::Extents(desc.Width, desc.Height, 1); +} + +angle::Result Blit9::boxFilter(Context9 *context9, + IDirect3DSurface9 *source, + IDirect3DSurface9 *dest) +{ + ANGLE_TRY(initialize(context9)); + + angle::ComPtr<IDirect3DBaseTexture9> texture = nullptr; + ANGLE_TRY(copySurfaceToTexture(context9, source, getSurfaceRect(source), &texture)); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + saveState(); + + device->SetTexture(0, texture.Get()); + device->SetRenderTarget(0, dest); + + ANGLE_TRY(setVertexShader(context9, SHADER_VS_STANDARD)); + ANGLE_TRY(setPixelShader(context9, SHADER_PS_PASSTHROUGH)); + + setCommonBlitState(); + device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); + device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); + + setViewportAndShaderConstants(getSurfaceRect(source), getSurfaceSize(source), + getSurfaceRect(dest), false); + + render(); + + restoreState(); + + return angle::Result::Continue; +} + +angle::Result Blit9::copy2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + Context9 *context9 = GetImplAs<Context9>(context); + + ANGLE_TRY(initialize(context9)); + + const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorAttachment(0); + ASSERT(colorbuffer); + + RenderTarget9 *renderTarget9 = nullptr; + ANGLE_TRY(colorbuffer->getRenderTarget(context, 0, &renderTarget9)); + ASSERT(renderTarget9); + + angle::ComPtr<IDirect3DSurface9> source = renderTarget9->getSurface(); + ASSERT(source); + + angle::ComPtr<IDirect3DSurface9> destSurface = nullptr; + TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage); + ANGLE_TRY( + storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, true, &destSurface)); + ASSERT(destSurface); + + ANGLE_TRY(copy(context9, source.Get(), nullptr, sourceRect, destFormat, destOffset, + destSurface.Get(), false, false, false)); + return angle::Result::Continue; +} + +angle::Result Blit9::copyCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) +{ + Context9 *context9 = GetImplAs<Context9>(context); + + ANGLE_TRY(initialize(context9)); + + const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorAttachment(0); + ASSERT(colorbuffer); + + RenderTarget9 *renderTarget9 = nullptr; + ANGLE_TRY(colorbuffer->getRenderTarget(context, 0, &renderTarget9)); + ASSERT(renderTarget9); + + angle::ComPtr<IDirect3DSurface9> source = renderTarget9->getSurface(); + ASSERT(source); + + angle::ComPtr<IDirect3DSurface9> destSurface = nullptr; + TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage); + ANGLE_TRY(storage9->getSurfaceLevel(context, target, level, true, &destSurface)); + ASSERT(destSurface); + + return copy(context9, source.Get(), nullptr, sourceRect, destFormat, destOffset, + destSurface.Get(), false, false, false); +} + +angle::Result Blit9::copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha) +{ + Context9 *context9 = GetImplAs<Context9>(context); + ANGLE_TRY(initialize(context9)); + + TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + + TextureStorage *sourceStorage = nullptr; + ANGLE_TRY(sourceD3D->getNativeTexture(context, &sourceStorage)); + + TextureStorage9_2D *sourceStorage9 = GetAs<TextureStorage9_2D>(sourceStorage); + ASSERT(sourceStorage9); + + TextureStorage9 *destStorage9 = GetAs<TextureStorage9>(storage); + ASSERT(destStorage9); + + ASSERT(sourceLevel == 0); + IDirect3DBaseTexture9 *sourceTexture = nullptr; + ANGLE_TRY(sourceStorage9->getBaseTexture(context, &sourceTexture)); + + angle::ComPtr<IDirect3DSurface9> sourceSurface = nullptr; + ANGLE_TRY(sourceStorage9->getSurfaceLevel(context, gl::TextureTarget::_2D, sourceLevel, true, + &sourceSurface)); + + angle::ComPtr<IDirect3DSurface9> destSurface = nullptr; + ANGLE_TRY(destStorage9->getSurfaceLevel(context, destTarget, destLevel, true, &destSurface)); + + return copy(context9, sourceSurface.Get(), sourceTexture, sourceRect, destFormat, destOffset, + destSurface.Get(), flipY, premultiplyAlpha, unmultiplyAlpha); +} + +angle::Result Blit9::copy(Context9 *context9, + IDirect3DSurface9 *source, + IDirect3DBaseTexture9 *sourceTexture, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + IDirect3DSurface9 *dest, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha) +{ + ASSERT(source != nullptr && dest != nullptr); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + D3DSURFACE_DESC sourceDesc; + D3DSURFACE_DESC destDesc; + source->GetDesc(&sourceDesc); + dest->GetDesc(&destDesc); + + // Check if it's possible to use StetchRect + if (sourceDesc.Format == destDesc.Format && (destDesc.Usage & D3DUSAGE_RENDERTARGET) && + d3d9_gl::IsFormatChannelEquivalent(destDesc.Format, destFormat) && !flipY && + premultiplyAlpha == unmultiplyAlpha) + { + RECT destRect = {destOffset.x, destOffset.y, + destOffset.x + (sourceRect.right - sourceRect.left), + destOffset.y + (sourceRect.bottom - sourceRect.top)}; + HRESULT result = device->StretchRect(source, &sourceRect, dest, &destRect, D3DTEXF_POINT); + ANGLE_TRY_HR(context9, result, "StretchRect failed to blit between textures"); + return angle::Result::Continue; + } + + angle::ComPtr<IDirect3DBaseTexture9> texture = sourceTexture; + RECT adjustedSourceRect = sourceRect; + gl::Extents sourceSize(sourceDesc.Width, sourceDesc.Height, 1); + + if (texture == nullptr) + { + ANGLE_TRY(copySurfaceToTexture(context9, source, sourceRect, &texture)); + + // copySurfaceToTexture only copies in the sourceRect area of the source surface. + // Adjust sourceRect so that it is now covering the entire source texture + adjustedSourceRect.left = 0; + adjustedSourceRect.right = sourceRect.right - sourceRect.left; + adjustedSourceRect.top = 0; + adjustedSourceRect.bottom = sourceRect.bottom - sourceRect.top; + + sourceSize.width = sourceRect.right - sourceRect.left; + sourceSize.height = sourceRect.bottom - sourceRect.top; + } + + ANGLE_TRY(formatConvert(context9, texture.Get(), adjustedSourceRect, sourceSize, destFormat, + destOffset, dest, flipY, premultiplyAlpha, unmultiplyAlpha)); + return angle::Result::Continue; +} + +angle::Result Blit9::formatConvert(Context9 *context9, + IDirect3DBaseTexture9 *source, + const RECT &sourceRect, + const gl::Extents &sourceSize, + GLenum destFormat, + const gl::Offset &destOffset, + IDirect3DSurface9 *dest, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha) +{ + ANGLE_TRY(initialize(context9)); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + saveState(); + + device->SetTexture(0, source); + device->SetRenderTarget(0, dest); + + RECT destRect; + destRect.left = destOffset.x; + destRect.right = destOffset.x + (sourceRect.right - sourceRect.left); + destRect.top = destOffset.y; + destRect.bottom = destOffset.y + (sourceRect.bottom - sourceRect.top); + + setViewportAndShaderConstants(sourceRect, sourceSize, destRect, flipY); + + setCommonBlitState(); + + angle::Result result = + setFormatConvertShaders(context9, destFormat, flipY, premultiplyAlpha, unmultiplyAlpha); + if (result == angle::Result::Continue) + { + render(); + } + + restoreState(); + + return result; +} + +angle::Result Blit9::setFormatConvertShaders(Context9 *context9, + GLenum destFormat, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha) +{ + ANGLE_TRY(setVertexShader(context9, SHADER_VS_STANDARD)); + + switch (destFormat) + { + case GL_RGBA: + case GL_BGRA_EXT: + case GL_RGB: + case GL_RG_EXT: + case GL_RED_EXT: + case GL_ALPHA: + if (premultiplyAlpha == unmultiplyAlpha) + { + ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK)); + } + else if (premultiplyAlpha) + { + ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK_PREMULTIPLY_ALPHA)); + } + else + { + ASSERT(unmultiplyAlpha); + ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK_UNMULTIPLY_ALPHA)); + } + break; + + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + if (premultiplyAlpha == unmultiplyAlpha) + { + ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE)); + } + else if (premultiplyAlpha) + { + ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE_PREMULTIPLY_ALPHA)); + } + else + { + ASSERT(unmultiplyAlpha); + ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE_UNMULTIPLY_ALPHA)); + } + break; + + default: + UNREACHABLE(); + } + + enum + { + X = 0, + Y = 1, + Z = 2, + W = 3 + }; + + // The meaning of this constant depends on the shader that was selected. + // See the shader assembly code above for details. + // Allocate one array for both registers and split it into two float4's. + float psConst[8] = {0}; + float *multConst = &psConst[0]; + float *addConst = &psConst[4]; + + switch (destFormat) + { + case GL_RGBA: + case GL_BGRA_EXT: + multConst[X] = 1; + multConst[Y] = 1; + multConst[Z] = 1; + multConst[W] = 1; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 0; + break; + + case GL_RGB: + multConst[X] = 1; + multConst[Y] = 1; + multConst[Z] = 1; + multConst[W] = 0; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 1; + break; + + case GL_RG_EXT: + multConst[X] = 1; + multConst[Y] = 1; + multConst[Z] = 0; + multConst[W] = 0; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 1; + break; + + case GL_RED_EXT: + multConst[X] = 1; + multConst[Y] = 0; + multConst[Z] = 0; + multConst[W] = 0; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 1; + break; + + case GL_ALPHA: + multConst[X] = 0; + multConst[Y] = 0; + multConst[Z] = 0; + multConst[W] = 1; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 0; + break; + + case GL_LUMINANCE: + multConst[X] = 1; + multConst[Y] = 0; + multConst[Z] = 0; + multConst[W] = 0; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 1; + break; + + case GL_LUMINANCE_ALPHA: + multConst[X] = 1; + multConst[Y] = 0; + multConst[Z] = 0; + multConst[W] = 1; + addConst[X] = 0; + addConst[Y] = 0; + addConst[Z] = 0; + addConst[W] = 0; + break; + + default: + UNREACHABLE(); + } + + mRenderer->getDevice()->SetPixelShaderConstantF(0, psConst, 2); + + return angle::Result::Continue; +} + +angle::Result Blit9::copySurfaceToTexture(Context9 *context9, + IDirect3DSurface9 *surface, + const RECT &sourceRect, + angle::ComPtr<IDirect3DBaseTexture9> *outTexture) +{ + ASSERT(surface); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + D3DSURFACE_DESC sourceDesc; + surface->GetDesc(&sourceDesc); + + // Copy the render target into a texture + angle::ComPtr<IDirect3DTexture9> texture; + HRESULT result = device->CreateTexture( + sourceRect.right - sourceRect.left, sourceRect.bottom - sourceRect.top, 1, + D3DUSAGE_RENDERTARGET, sourceDesc.Format, D3DPOOL_DEFAULT, &texture, nullptr); + ANGLE_TRY_HR(context9, result, "Failed to allocate internal texture for blit"); + + angle::ComPtr<IDirect3DSurface9> textureSurface; + result = texture->GetSurfaceLevel(0, &textureSurface); + ANGLE_TRY_HR(context9, result, "Failed to query surface of internal blit texture"); + + mRenderer->endScene(); + result = device->StretchRect(surface, &sourceRect, textureSurface.Get(), nullptr, D3DTEXF_NONE); + ANGLE_TRY_HR(context9, result, "Failed to copy between internal blit textures"); + *outTexture = texture; + + return angle::Result::Continue; +} + +void Blit9::setViewportAndShaderConstants(const RECT &sourceRect, + const gl::Extents &sourceSize, + const RECT &destRect, + bool flipY) +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + D3DVIEWPORT9 vp; + vp.X = destRect.left; + vp.Y = destRect.top; + vp.Width = destRect.right - destRect.left; + vp.Height = destRect.bottom - destRect.top; + vp.MinZ = 0.0f; + vp.MaxZ = 1.0f; + device->SetViewport(&vp); + + float vertexConstants[8] = { + // halfPixelAdjust + -1.0f / vp.Width, + 1.0f / vp.Height, + 0, + 0, + // texcoordOffset + static_cast<float>(sourceRect.left) / sourceSize.width, + static_cast<float>(flipY ? sourceRect.bottom : sourceRect.top) / sourceSize.height, + static_cast<float>(sourceRect.right - sourceRect.left) / sourceSize.width, + static_cast<float>(flipY ? sourceRect.top - sourceRect.bottom + : sourceRect.bottom - sourceRect.top) / + sourceSize.height, + }; + + device->SetVertexShaderConstantF(0, vertexConstants, 2); +} + +void Blit9::setCommonBlitState() +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + device->SetDepthStencilSurface(nullptr); + + device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); + device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0); + device->SetRenderState(D3DRS_COLORWRITEENABLE, + D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | + D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED); + device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE); + device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE); + + device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); + device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); + device->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, FALSE); + device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); + device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); + + RECT scissorRect = {}; // Scissoring is disabled for flipping, but we need this to capture and + // restore the old rectangle + device->SetScissorRect(&scissorRect); + + for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) + { + device->SetStreamSourceFreq(i, 1); + } +} + +void Blit9::render() +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + device->SetStreamSource(0, mQuadVertexBuffer, 0, 2 * sizeof(float)); + device->SetVertexDeclaration(mQuadVertexDeclaration); + + mRenderer->startScene(); + device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2); +} + +void Blit9::saveState() +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + HRESULT hr; + + device->GetDepthStencilSurface(&mSavedDepthStencil); + device->GetRenderTarget(0, &mSavedRenderTarget); + + if (mSavedStateBlock == nullptr) + { + hr = device->BeginStateBlock(); + ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY); + + setCommonBlitState(); + + static const float mockConst[8] = {0}; + + device->SetVertexShader(nullptr); + device->SetVertexShaderConstantF(0, mockConst, 2); + device->SetPixelShader(nullptr); + device->SetPixelShaderConstantF(0, mockConst, 2); + + D3DVIEWPORT9 mockVp; + mockVp.X = 0; + mockVp.Y = 0; + mockVp.Width = 1; + mockVp.Height = 1; + mockVp.MinZ = 0; + mockVp.MaxZ = 1; + + device->SetViewport(&mockVp); + + device->SetTexture(0, nullptr); + + device->SetStreamSource(0, mQuadVertexBuffer, 0, 0); + + device->SetVertexDeclaration(mQuadVertexDeclaration); + + hr = device->EndStateBlock(&mSavedStateBlock); + ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY); + } + + ASSERT(mSavedStateBlock != nullptr); + + if (mSavedStateBlock != nullptr) + { + hr = mSavedStateBlock->Capture(); + ASSERT(SUCCEEDED(hr)); + } +} + +void Blit9::restoreState() +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + device->SetDepthStencilSurface(mSavedDepthStencil); + SafeRelease(mSavedDepthStencil); + + device->SetRenderTarget(0, mSavedRenderTarget); + SafeRelease(mSavedRenderTarget); + + ASSERT(mSavedStateBlock != nullptr); + + if (mSavedStateBlock != nullptr) + { + mSavedStateBlock->Apply(); + } +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.h new file mode 100644 index 0000000000..1c99413ecd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Blit9.h @@ -0,0 +1,166 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Blit9.cpp: Surface copy utility class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_BLIT9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_BLIT9_H_ + +#include "common/PackedEnums.h" +#include "common/angleutils.h" +#include "libANGLE/Error.h" + +namespace gl +{ +class Context; +class Framebuffer; +class Texture; +struct Extents; +struct Offset; +} // namespace gl + +namespace rx +{ +class Context9; +class Renderer9; +class TextureStorage; + +namespace d3d +{ +class Context; +} // namespace d3d + +class Blit9 : angle::NonCopyable +{ + public: + explicit Blit9(Renderer9 *renderer); + ~Blit9(); + + angle::Result initialize(Context9 *context9); + + // Copy from source surface to dest surface. + // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left) + angle::Result copy2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level); + angle::Result copyCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level); + angle::Result copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha); + + // 2x2 box filter sample from source to dest. + // Requires that source is RGB(A) and dest has the same format as source. + angle::Result boxFilter(Context9 *context9, IDirect3DSurface9 *source, IDirect3DSurface9 *dest); + + private: + Renderer9 *mRenderer; + + bool mGeometryLoaded; + IDirect3DVertexBuffer9 *mQuadVertexBuffer; + IDirect3DVertexDeclaration9 *mQuadVertexDeclaration; + + // Copy from source texture to dest surface. + // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left) + // source is interpreted as RGBA and destFormat specifies the desired result format. For + // example, if destFormat = GL_RGB, the alpha channel will be forced to 0. + angle::Result formatConvert(Context9 *context9, + IDirect3DBaseTexture9 *source, + const RECT &sourceRect, + const gl::Extents &sourceSize, + GLenum destFormat, + const gl::Offset &destOffset, + IDirect3DSurface9 *dest, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha); + angle::Result setFormatConvertShaders(Context9 *context9, + GLenum destFormat, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha); + + angle::Result copy(Context9 *context9, + IDirect3DSurface9 *source, + IDirect3DBaseTexture9 *sourceTexture, + const RECT &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + IDirect3DSurface9 *dest, + bool flipY, + bool premultiplyAlpha, + bool unmultiplyAlpha); + angle::Result copySurfaceToTexture(Context9 *context9, + IDirect3DSurface9 *surface, + const RECT &sourceRect, + angle::ComPtr<IDirect3DBaseTexture9> *outTexture); + void setViewportAndShaderConstants(const RECT &sourceRect, + const gl::Extents &sourceSize, + const RECT &destRect, + bool flipY); + void setCommonBlitState(); + RECT getSurfaceRect(IDirect3DSurface9 *surface) const; + gl::Extents getSurfaceSize(IDirect3DSurface9 *surface) const; + + // This enum is used to index mCompiledShaders and mShaderSource. + enum ShaderId + { + SHADER_VS_STANDARD, + SHADER_PS_PASSTHROUGH, + SHADER_PS_LUMINANCE, + SHADER_PS_LUMINANCE_PREMULTIPLY_ALPHA, + SHADER_PS_LUMINANCE_UNMULTIPLY_ALPHA, + SHADER_PS_COMPONENTMASK, + SHADER_PS_COMPONENTMASK_PREMULTIPLY_ALPHA, + SHADER_PS_COMPONENTMASK_UNMULTIPLY_ALPHA, + SHADER_COUNT, + }; + + // This actually contains IDirect3DVertexShader9 or IDirect3DPixelShader9 casted to IUnknown. + IUnknown *mCompiledShaders[SHADER_COUNT]; + + template <class D3DShaderType> + angle::Result setShader(Context9 *, + ShaderId source, + const char *profile, + angle::Result (Renderer9::*createShader)(d3d::Context *context, + const DWORD *, + size_t length, + D3DShaderType **outShader), + HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType *)); + + angle::Result setVertexShader(Context9 *context9, ShaderId shader); + angle::Result setPixelShader(Context9 *context9, ShaderId shader); + void render(); + + void saveState(); + void restoreState(); + IDirect3DStateBlock9 *mSavedStateBlock; + IDirect3DSurface9 *mSavedRenderTarget; + IDirect3DSurface9 *mSavedDepthStencil; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_BLIT9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp new file mode 100644 index 0000000000..dbf875134b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp @@ -0,0 +1,141 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Buffer9.cpp Defines the Buffer9 class. + +#include "libANGLE/renderer/d3d/d3d9/Buffer9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" + +namespace rx +{ + +Buffer9::Buffer9(const gl::BufferState &state, Renderer9 *renderer) + : BufferD3D(state, renderer), mSize(0) +{} + +Buffer9::~Buffer9() +{ + mSize = 0; +} + +size_t Buffer9::getSize() const +{ + return mSize; +} + +bool Buffer9::supportsDirectBinding() const +{ + return false; +} + +angle::Result Buffer9::setData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + gl::BufferUsage usage) +{ + if (size > mMemory.size()) + { + ANGLE_CHECK_GL_ALLOC(GetImplAs<Context9>(context), mMemory.resize(size)); + } + + mSize = size; + if (data && size > 0) + { + memcpy(mMemory.data(), data, size); + } + + updateD3DBufferUsage(context, usage); + + invalidateStaticData(context); + + return angle::Result::Continue; +} + +angle::Result Buffer9::getData(const gl::Context *context, const uint8_t **outData) +{ + if (mMemory.empty()) + { + *outData = nullptr; + } + else + { + *outData = mMemory.data(); + } + return angle::Result::Continue; +} + +angle::Result Buffer9::setSubData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + size_t offset) +{ + if (offset + size > mMemory.size()) + { + ANGLE_CHECK_GL_ALLOC(GetImplAs<Context9>(context), mMemory.resize(size + offset)); + } + + mSize = std::max(mSize, offset + size); + if (data && size > 0) + { + memcpy(mMemory.data() + offset, data, size); + } + + invalidateStaticData(context); + + return angle::Result::Continue; +} + +angle::Result Buffer9::copySubData(const gl::Context *context, + BufferImpl *source, + GLintptr sourceOffset, + GLintptr destOffset, + GLsizeiptr size) +{ + // Note: this method is currently unreachable + Buffer9 *sourceBuffer = GetAs<Buffer9>(source); + ASSERT(sourceBuffer); + + memcpy(mMemory.data() + destOffset, sourceBuffer->mMemory.data() + sourceOffset, size); + + invalidateStaticData(context); + + return angle::Result::Continue; +} + +// We do not support buffer mapping in D3D9 +angle::Result Buffer9::map(const gl::Context *context, GLenum access, void **mapPtr) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Buffer9::mapRange(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + void **mapPtr) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Buffer9::unmap(const gl::Context *context, GLboolean *result) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Buffer9::markTransformFeedbackUsage(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.h new file mode 100644 index 0000000000..dad120d75b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Buffer9.h @@ -0,0 +1,63 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Buffer9.h: Defines the rx::Buffer9 class which implements rx::BufferImpl via rx::BufferD3D. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_ + +#include "common/MemoryBuffer.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" + +namespace rx +{ +class Renderer9; + +class Buffer9 : public BufferD3D +{ + public: + Buffer9(const gl::BufferState &state, Renderer9 *renderer); + ~Buffer9() override; + + // BufferD3D implementation + size_t getSize() const override; + bool supportsDirectBinding() const override; + angle::Result getData(const gl::Context *context, const uint8_t **outData) override; + + // BufferImpl implementation + angle::Result setData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + gl::BufferUsage usage) override; + angle::Result setSubData(const gl::Context *context, + gl::BufferBinding target, + const void *data, + size_t size, + size_t offset) override; + angle::Result copySubData(const gl::Context *context, + BufferImpl *source, + GLintptr sourceOffset, + GLintptr destOffset, + GLsizeiptr size) override; + angle::Result map(const gl::Context *context, GLenum access, void **mapPtr) override; + angle::Result mapRange(const gl::Context *context, + size_t offset, + size_t length, + GLbitfield access, + void **mapPtr) override; + angle::Result unmap(const gl::Context *context, GLboolean *result) override; + angle::Result markTransformFeedbackUsage(const gl::Context *context) override; + + private: + angle::MemoryBuffer mMemory; + size_t mSize; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.cpp new file mode 100644 index 0000000000..b879d9c93b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.cpp @@ -0,0 +1,529 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Context9: +// D3D9-specific functionality associated with a GL Context. +// + +#include "libANGLE/renderer/d3d/d3d9/Context9.h" + +#include "common/entry_points_enum_autogen.h" +#include "common/string_utils.h" +#include "libANGLE/renderer/OverlayImpl.h" +#include "libANGLE/renderer/d3d/CompilerD3D.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/SamplerD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d9/Buffer9.h" +#include "libANGLE/renderer/d3d/d3d9/Fence9.h" +#include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/Query9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/StateManager9.h" +#include "libANGLE/renderer/d3d/d3d9/VertexArray9.h" + +namespace rx +{ + +Context9::Context9(const gl::State &state, gl::ErrorSet *errorSet, Renderer9 *renderer) + : ContextD3D(state, errorSet), mRenderer(renderer) +{} + +Context9::~Context9() {} + +angle::Result Context9::initialize() +{ + return angle::Result::Continue; +} + +void Context9::onDestroy(const gl::Context *context) +{ + mIncompleteTextures.onDestroy(context); +} + +CompilerImpl *Context9::createCompiler() +{ + return new CompilerD3D(SH_HLSL_3_0_OUTPUT); +} + +ShaderImpl *Context9::createShader(const gl::ShaderState &data) +{ + return new ShaderD3D(data, mRenderer); +} + +ProgramImpl *Context9::createProgram(const gl::ProgramState &data) +{ + return new ProgramD3D(data, mRenderer); +} + +FramebufferImpl *Context9::createFramebuffer(const gl::FramebufferState &data) +{ + return new Framebuffer9(data, mRenderer); +} + +TextureImpl *Context9::createTexture(const gl::TextureState &state) +{ + switch (state.getType()) + { + case gl::TextureType::_2D: + // GL_TEXTURE_VIDEO_IMAGE_WEBGL maps to 2D texture on Windows platform. + case gl::TextureType::VideoImage: + return new TextureD3D_2D(state, mRenderer); + case gl::TextureType::CubeMap: + return new TextureD3D_Cube(state, mRenderer); + case gl::TextureType::External: + return new TextureD3D_External(state, mRenderer); + default: + UNREACHABLE(); + } + return nullptr; +} + +RenderbufferImpl *Context9::createRenderbuffer(const gl::RenderbufferState &state) +{ + return new RenderbufferD3D(state, mRenderer); +} + +BufferImpl *Context9::createBuffer(const gl::BufferState &state) +{ + return new Buffer9(state, mRenderer); +} + +VertexArrayImpl *Context9::createVertexArray(const gl::VertexArrayState &data) +{ + return new VertexArray9(data); +} + +QueryImpl *Context9::createQuery(gl::QueryType type) +{ + return new Query9(mRenderer, type); +} + +FenceNVImpl *Context9::createFenceNV() +{ + return new FenceNV9(mRenderer); +} + +SyncImpl *Context9::createSync() +{ + // D3D9 doesn't support ES 3.0 and its sync objects. + UNREACHABLE(); + return nullptr; +} + +TransformFeedbackImpl *Context9::createTransformFeedback(const gl::TransformFeedbackState &state) +{ + UNREACHABLE(); + return nullptr; +} + +SamplerImpl *Context9::createSampler(const gl::SamplerState &state) +{ + return new SamplerD3D(state); +} + +ProgramPipelineImpl *Context9::createProgramPipeline(const gl::ProgramPipelineState &data) +{ + UNREACHABLE(); + return nullptr; +} + +MemoryObjectImpl *Context9::createMemoryObject() +{ + UNREACHABLE(); + return nullptr; +} + +SemaphoreImpl *Context9::createSemaphore() +{ + UNREACHABLE(); + return nullptr; +} + +OverlayImpl *Context9::createOverlay(const gl::OverlayState &state) +{ + // Not implemented. + return new OverlayImpl(state); +} + +angle::Result Context9::flush(const gl::Context *context) +{ + return mRenderer->flush(context); +} + +angle::Result Context9::finish(const gl::Context *context) +{ + return mRenderer->finish(context); +} + +angle::Result Context9::drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count) +{ + return mRenderer->genericDrawArrays(context, mode, first, count, 0); +} + +angle::Result Context9::drawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount) +{ + return mRenderer->genericDrawArrays(context, mode, first, count, instanceCount); +} + +angle::Result Context9::drawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Continue; +} + +angle::Result Context9::drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices) +{ + return mRenderer->genericDrawElements(context, mode, count, type, indices, 0); +} + +angle::Result Context9::drawElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Continue; +} + +angle::Result Context9::drawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) +{ + return mRenderer->genericDrawElements(context, mode, count, type, indices, instances); +} + +angle::Result Context9::drawElementsInstancedBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Continue; +} + +angle::Result Context9::drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Continue; +} + +angle::Result Context9::drawRangeElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices) +{ + return mRenderer->genericDrawElements(context, mode, count, type, indices, 0); +} + +angle::Result Context9::drawRangeElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Continue; +} + +angle::Result Context9::drawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::drawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::multiDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) +{ + return rx::MultiDrawArraysGeneral(this, context, mode, firsts, counts, drawcount); +} + +angle::Result Context9::multiDrawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + return rx::MultiDrawArraysInstancedGeneral(this, context, mode, firsts, counts, instanceCounts, + drawcount); +} + +angle::Result Context9::multiDrawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + UNREACHABLE(); + return angle::Result::Stop; +} + +angle::Result Context9::multiDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + GLsizei drawcount) +{ + return rx::MultiDrawElementsGeneral(this, context, mode, counts, type, indices, drawcount); +} + +angle::Result Context9::multiDrawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + return rx::MultiDrawElementsInstancedGeneral(this, context, mode, counts, type, indices, + instanceCounts, drawcount); +} + +angle::Result Context9::multiDrawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + UNREACHABLE(); + return angle::Result::Stop; +} + +angle::Result Context9::multiDrawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::multiDrawElementsInstancedBaseVertexBaseInstance( + const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +gl::GraphicsResetStatus Context9::getResetStatus() +{ + return mRenderer->getResetStatus(); +} + +angle::Result Context9::insertEventMarker(GLsizei length, const char *marker) +{ + mRenderer->getAnnotator()->setMarker(/*context=*/nullptr, marker); + return angle::Result::Continue; +} + +angle::Result Context9::pushGroupMarker(GLsizei length, const char *marker) +{ + mRenderer->getAnnotator()->beginEvent(nullptr, angle::EntryPoint::GLPushGroupMarkerEXT, marker, + marker); + mMarkerStack.push(std::string(marker)); + return angle::Result::Continue; +} + +angle::Result Context9::popGroupMarker() +{ + const char *marker = nullptr; + if (!mMarkerStack.empty()) + { + marker = mMarkerStack.top().c_str(); + mMarkerStack.pop(); + mRenderer->getAnnotator()->endEvent(nullptr, marker, + angle::EntryPoint::GLPopGroupMarkerEXT); + } + return angle::Result::Continue; +} + +angle::Result Context9::pushDebugGroup(const gl::Context *context, + GLenum source, + GLuint id, + const std::string &message) +{ + // Fall through to the EXT_debug_marker functions + return pushGroupMarker(static_cast<GLsizei>(message.size()), message.c_str()); +} + +angle::Result Context9::popDebugGroup(const gl::Context *context) +{ + // Fall through to the EXT_debug_marker functions + return popGroupMarker(); +} + +angle::Result Context9::syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + const gl::State::DirtyBits &bitMask, + gl::Command command) +{ + mRenderer->getStateManager()->syncState(mState, dirtyBits); + return angle::Result::Continue; +} + +GLint Context9::getGPUDisjoint() +{ + return mRenderer->getGPUDisjoint(); +} + +GLint64 Context9::getTimestamp() +{ + return mRenderer->getTimestamp(); +} + +angle::Result Context9::onMakeCurrent(const gl::Context *context) +{ + mRenderer->getStateManager()->setAllDirtyBits(); + return mRenderer->ensureVertexDataManagerInitialized(context); +} + +gl::Caps Context9::getNativeCaps() const +{ + return mRenderer->getNativeCaps(); +} + +const gl::TextureCapsMap &Context9::getNativeTextureCaps() const +{ + return mRenderer->getNativeTextureCaps(); +} + +const gl::Extensions &Context9::getNativeExtensions() const +{ + return mRenderer->getNativeExtensions(); +} + +const gl::Limitations &Context9::getNativeLimitations() const +{ + return mRenderer->getNativeLimitations(); +} + +ShPixelLocalStorageType Context9::getNativePixelLocalStorageType() const +{ + return mRenderer->getNativePixelLocalStorageType(); +} + +angle::Result Context9::dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::memoryBarrier(const gl::Context *context, GLbitfield barriers) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) +{ + ANGLE_HR_UNREACHABLE(this); + return angle::Result::Stop; +} + +angle::Result Context9::getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) +{ + return mIncompleteTextures.getIncompleteTexture(context, type, gl::SamplerFormat::Float, + nullptr, textureOut); +} + +void Context9::handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) +{ + ASSERT(FAILED(hr)); + + if (d3d9::isDeviceLostError(hr)) + { + mRenderer->notifyDeviceLost(); + } + + GLenum glErrorCode = DefaultGLErrorCode(hr); + + std::stringstream errorStream; + errorStream << "Internal D3D9 error: " << gl::FmtHR(hr) << ": " << message; + + mErrors->handleError(glErrorCode, errorStream.str().c_str(), file, function, line); +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.h new file mode 100644 index 0000000000..ce3e930295 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Context9.h @@ -0,0 +1,265 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Context9: +// D3D9-specific functionality associated with a GL Context. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_ + +#include <stack> +#include "libANGLE/renderer/d3d/ContextD3D.h" + +namespace rx +{ +class Renderer9; + +class Context9 : public ContextD3D +{ + public: + Context9(const gl::State &state, gl::ErrorSet *errorSet, Renderer9 *renderer); + ~Context9() override; + + angle::Result initialize() override; + void onDestroy(const gl::Context *context) override; + + // Shader creation + CompilerImpl *createCompiler() override; + ShaderImpl *createShader(const gl::ShaderState &data) override; + ProgramImpl *createProgram(const gl::ProgramState &data) override; + + // Framebuffer creation + FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override; + + // Texture creation + TextureImpl *createTexture(const gl::TextureState &state) override; + + // Renderbuffer creation + RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override; + + // Buffer creation + BufferImpl *createBuffer(const gl::BufferState &state) override; + + // Vertex Array creation + VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override; + + // Query and Fence creation + QueryImpl *createQuery(gl::QueryType type) override; + FenceNVImpl *createFenceNV() override; + SyncImpl *createSync() override; + + // Transform Feedback creation + TransformFeedbackImpl *createTransformFeedback( + const gl::TransformFeedbackState &state) override; + + // Sampler object creation + SamplerImpl *createSampler(const gl::SamplerState &state) override; + + // Program Pipeline object creation + ProgramPipelineImpl *createProgramPipeline(const gl::ProgramPipelineState &data) override; + + // Memory object creation. + MemoryObjectImpl *createMemoryObject() override; + + // Semaphore creation. + SemaphoreImpl *createSemaphore() override; + + // Overlay creation. + OverlayImpl *createOverlay(const gl::OverlayState &state) override; + + // Flush and finish. + angle::Result flush(const gl::Context *context) override; + angle::Result finish(const gl::Context *context) override; + + // Drawing methods. + angle::Result drawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count) override; + angle::Result drawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount) override; + angle::Result drawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) override; + + angle::Result drawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices) override; + angle::Result drawElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) override; + angle::Result drawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) override; + angle::Result drawElementsInstancedBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex) override; + angle::Result drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances, + GLint baseVertex, + GLuint baseInstance) override; + angle::Result drawRangeElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices) override; + angle::Result drawRangeElementsBaseVertex(const gl::Context *context, + gl::PrimitiveMode mode, + GLuint start, + GLuint end, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLint baseVertex) override; + angle::Result drawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect) override; + angle::Result drawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect) override; + + angle::Result multiDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) override; + angle::Result multiDrawArraysInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) override; + angle::Result multiDrawArraysIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) override; + angle::Result multiDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + GLsizei drawcount) override; + angle::Result multiDrawElementsInstanced(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) override; + angle::Result multiDrawElementsIndirect(const gl::Context *context, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) override; + angle::Result multiDrawArraysInstancedBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) override; + angle::Result multiDrawElementsInstancedBaseVertexBaseInstance(const gl::Context *context, + gl::PrimitiveMode mode, + const GLsizei *counts, + gl::DrawElementsType type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) override; + + // Device loss + gl::GraphicsResetStatus getResetStatus() override; + + // EXT_debug_marker + angle::Result insertEventMarker(GLsizei length, const char *marker) override; + angle::Result pushGroupMarker(GLsizei length, const char *marker) override; + angle::Result popGroupMarker() override; + + // KHR_debug + angle::Result pushDebugGroup(const gl::Context *context, + GLenum source, + GLuint id, + const std::string &message) override; + angle::Result popDebugGroup(const gl::Context *context) override; + + // State sync with dirty bits. + angle::Result syncState(const gl::Context *context, + const gl::State::DirtyBits &dirtyBits, + const gl::State::DirtyBits &bitMask, + gl::Command command) override; + + // Disjoint timer queries + GLint getGPUDisjoint() override; + GLint64 getTimestamp() override; + + // Context switching + angle::Result onMakeCurrent(const gl::Context *context) override; + + // Caps queries + gl::Caps getNativeCaps() const override; + const gl::TextureCapsMap &getNativeTextureCaps() const override; + const gl::Extensions &getNativeExtensions() const override; + const gl::Limitations &getNativeLimitations() const override; + ShPixelLocalStorageType getNativePixelLocalStorageType() const override; + + angle::Result dispatchCompute(const gl::Context *context, + GLuint numGroupsX, + GLuint numGroupsY, + GLuint numGroupsZ) override; + angle::Result dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) override; + + angle::Result memoryBarrier(const gl::Context *context, GLbitfield barriers) override; + angle::Result memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) override; + + Renderer9 *getRenderer() const { return mRenderer; } + + angle::Result getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut); + + void handleResult(HRESULT hr, + const char *message, + const char *file, + const char *function, + unsigned int line) override; + + private: + Renderer9 *mRenderer; + IncompleteTextureSet mIncompleteTextures; + std::stack<std::string> mMarkerStack; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.cpp new file mode 100644 index 0000000000..7e597e564b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.cpp @@ -0,0 +1,48 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DebugAnnotator9.h: D3D9 helpers for adding trace annotations. +// + +#include "libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h" + +#include "common/platform.h" + +namespace rx +{ + +void DebugAnnotator9::beginEvent(gl::Context *context, + angle::EntryPoint entryPoint, + const char *eventName, + const char *eventMessage) +{ + angle::LoggingAnnotator::beginEvent(context, entryPoint, eventName, eventMessage); + std::mbstate_t state = std::mbstate_t(); + std::mbsrtowcs(mWCharMessage, &eventMessage, kMaxMessageLength, &state); + D3DPERF_BeginEvent(0, mWCharMessage); +} + +void DebugAnnotator9::endEvent(gl::Context *context, + const char *eventName, + angle::EntryPoint entryPoint) +{ + angle::LoggingAnnotator::endEvent(context, eventName, entryPoint); + D3DPERF_EndEvent(); +} + +void DebugAnnotator9::setMarker(gl::Context *context, const char *markerName) +{ + angle::LoggingAnnotator::setMarker(context, markerName); + std::mbstate_t state = std::mbstate_t(); + std::mbsrtowcs(mWCharMessage, &markerName, kMaxMessageLength, &state); + D3DPERF_SetMarker(0, mWCharMessage); +} + +bool DebugAnnotator9::getStatus(const gl::Context *context) +{ + return !!D3DPERF_GetStatus(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h new file mode 100644 index 0000000000..40f8189bea --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h @@ -0,0 +1,38 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// DebugAnnotator9.h: D3D9 helpers for adding trace annotations. +// + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_DEBUGANNOTATOR9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_DEBUGANNOTATOR9_H_ + +#include "libANGLE/LoggingAnnotator.h" + +namespace rx +{ + +class DebugAnnotator9 : public angle::LoggingAnnotator +{ + public: + DebugAnnotator9() {} + void beginEvent(gl::Context *context, + angle::EntryPoint entryPoint, + const char *eventName, + const char *eventMessage) override; + void endEvent(gl::Context *context, + const char *eventName, + angle::EntryPoint entryPoint) override; + void setMarker(gl::Context *context, const char *markerName) override; + bool getStatus(const gl::Context *context) override; + + private: + static constexpr size_t kMaxMessageLength = 256; + wchar_t mWCharMessage[kMaxMessageLength]; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_DEBUGANNOTATOR9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp new file mode 100644 index 0000000000..e844a9ae70 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp @@ -0,0 +1,73 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Fence9.cpp: Defines the rx::FenceNV9 class. + +#include "libANGLE/renderer/d3d/d3d9/Fence9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ + +FenceNV9::FenceNV9(Renderer9 *renderer) : FenceNVImpl(), mRenderer(renderer), mQuery(nullptr) {} + +FenceNV9::~FenceNV9() +{ + SafeRelease(mQuery); +} + +angle::Result FenceNV9::set(const gl::Context *context, GLenum condition) +{ + if (!mQuery) + { + ANGLE_TRY(mRenderer->allocateEventQuery(context, &mQuery)); + } + + HRESULT result = mQuery->Issue(D3DISSUE_END); + if (FAILED(result)) + { + SafeRelease(mQuery); + } + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to end event query"); + return angle::Result::Continue; +} + +angle::Result FenceNV9::test(const gl::Context *context, GLboolean *outFinished) +{ + return testHelper(GetImplAs<Context9>(context), true, outFinished); +} + +angle::Result FenceNV9::finish(const gl::Context *context) +{ + GLboolean finished = GL_FALSE; + while (finished != GL_TRUE) + { + ANGLE_TRY(testHelper(GetImplAs<Context9>(context), true, &finished)); + Sleep(0); + } + + return angle::Result::Continue; +} + +angle::Result FenceNV9::testHelper(Context9 *context9, + bool flushCommandBuffer, + GLboolean *outFinished) +{ + ASSERT(mQuery); + + DWORD getDataFlags = (flushCommandBuffer ? D3DGETDATA_FLUSH : 0); + HRESULT result = mQuery->GetData(nullptr, 0, getDataFlags); + ANGLE_TRY_HR(context9, result, "Failed to get query data"); + ASSERT(result == S_OK || result == S_FALSE); + *outFinished = ((result == S_OK) ? GL_TRUE : GL_FALSE); + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.h new file mode 100644 index 0000000000..c46671c102 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Fence9.h @@ -0,0 +1,39 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Fence9.h: Defines the rx::FenceNV9 class which implements rx::FenceNVImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_FENCE9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_FENCE9_H_ + +#include "libANGLE/renderer/FenceNVImpl.h" +#include "libANGLE/renderer/SyncImpl.h" + +namespace rx +{ +class Context9; +class Renderer9; + +class FenceNV9 : public FenceNVImpl +{ + public: + explicit FenceNV9(Renderer9 *renderer); + ~FenceNV9() override; + + void onDestroy(const gl::Context *context) override {} + angle::Result set(const gl::Context *context, GLenum condition) override; + angle::Result test(const gl::Context *context, GLboolean *outFinished) override; + angle::Result finish(const gl::Context *context) override; + + private: + angle::Result testHelper(Context9 *context9, bool flushCommandBuffer, GLboolean *outFinished); + + Renderer9 *mRenderer; + IDirect3DQuery9 *mQuery; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_FENCE9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp new file mode 100644 index 0000000000..f90fefac20 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp @@ -0,0 +1,416 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Framebuffer9.cpp: Implements the Framebuffer9 class. + +#include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Texture.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/ContextImpl.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" +#include "libANGLE/renderer/renderer_utils.h" + +namespace rx +{ +Framebuffer9::Framebuffer9(const gl::FramebufferState &data, Renderer9 *renderer) + : FramebufferD3D(data, renderer), mRenderer(renderer) +{ + ASSERT(mRenderer != nullptr); +} + +Framebuffer9::~Framebuffer9() {} + +angle::Result Framebuffer9::discard(const gl::Context *context, + size_t count, + const GLenum *attachments) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Framebuffer9::invalidate(const gl::Context *context, + size_t count, + const GLenum *attachments) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Framebuffer9::invalidateSub(const gl::Context *context, + size_t count, + const GLenum *attachments, + const gl::Rectangle &area) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Framebuffer9::clearImpl(const gl::Context *context, + const ClearParameters &clearParams) +{ + ANGLE_TRY(mRenderer->applyRenderTarget(context, mRenderTargetCache.getColors()[0], + mRenderTargetCache.getDepthStencil())); + + const gl::State &glState = context->getState(); + float nearZ = glState.getNearPlane(); + float farZ = glState.getFarPlane(); + mRenderer->setViewport(glState.getViewport(), nearZ, farZ, gl::PrimitiveMode::Triangles, + glState.getRasterizerState().frontFace, true); + + mRenderer->setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled()); + + mRenderer->clear(clearParams, mRenderTargetCache.getColors()[0], + mRenderTargetCache.getDepthStencil()); + return angle::Result::Continue; +} + +angle::Result Framebuffer9::readPixelsImpl(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + size_t outputPitch, + const gl::PixelPackState &pack, + gl::Buffer *packBuffer, + uint8_t *pixels) +{ + const gl::FramebufferAttachment *colorbuffer = mState.getColorAttachment(0); + ASSERT(colorbuffer); + + RenderTarget9 *renderTarget = nullptr; + ANGLE_TRY(colorbuffer->getRenderTarget(context, 0, &renderTarget)); + ASSERT(renderTarget); + + IDirect3DSurface9 *surface = renderTarget->getSurface(); + ASSERT(surface); + + D3DSURFACE_DESC desc; + surface->GetDesc(&desc); + + Context9 *context9 = GetImplAs<Context9>(context); + + if (desc.MultiSampleType != D3DMULTISAMPLE_NONE) + { + UNIMPLEMENTED(); // FIXME: Requires resolve using StretchRect into non-multisampled render + // target + SafeRelease(surface); + ANGLE_TRY_HR(context9, E_OUTOFMEMORY, + "ReadPixels is unimplemented for multisampled framebuffer attachments."); + } + + IDirect3DDevice9 *device = mRenderer->getDevice(); + ASSERT(device); + + HRESULT result; + IDirect3DSurface9 *systemSurface = nullptr; + bool directToPixels = + !pack.reverseRowOrder && pack.alignment <= 4 && mRenderer->getShareHandleSupport() && + area.x == 0 && area.y == 0 && static_cast<UINT>(area.width) == desc.Width && + static_cast<UINT>(area.height) == desc.Height && desc.Format == D3DFMT_A8R8G8B8 && + format == GL_BGRA_EXT && type == GL_UNSIGNED_BYTE; + if (directToPixels) + { + // Use the pixels ptr as a shared handle to write directly into client's memory + result = device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, + D3DPOOL_SYSTEMMEM, &systemSurface, + reinterpret_cast<void **>(&pixels)); + if (FAILED(result)) + { + // Try again without the shared handle + directToPixels = false; + } + } + + if (!directToPixels) + { + result = device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, + D3DPOOL_SYSTEMMEM, &systemSurface, nullptr); + if (FAILED(result)) + { + ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); + SafeRelease(surface); + ANGLE_TRY_HR(context9, E_OUTOFMEMORY, + "Failed to allocate internal texture for ReadPixels."); + } + } + + result = device->GetRenderTargetData(surface, systemSurface); + SafeRelease(surface); + + if (FAILED(result)) + { + SafeRelease(systemSurface); + + // It turns out that D3D will sometimes produce more error + // codes than those documented. + if (d3d9::isDeviceLostError(result)) + { + mRenderer->notifyDeviceLost(); + } + else + { + UNREACHABLE(); + } + + ANGLE_TRY_HR(context9, E_OUTOFMEMORY, "Failed to read internal render target data."); + } + + if (directToPixels) + { + SafeRelease(systemSurface); + return angle::Result::Continue; + } + + RECT rect; + rect.left = gl::clamp(area.x, 0L, static_cast<LONG>(desc.Width)); + rect.top = gl::clamp(area.y, 0L, static_cast<LONG>(desc.Height)); + rect.right = gl::clamp(area.x + area.width, 0L, static_cast<LONG>(desc.Width)); + rect.bottom = gl::clamp(area.y + area.height, 0L, static_cast<LONG>(desc.Height)); + + D3DLOCKED_RECT lock; + result = systemSurface->LockRect(&lock, &rect, D3DLOCK_READONLY); + + if (FAILED(result)) + { + UNREACHABLE(); + SafeRelease(systemSurface); + + ANGLE_TRY_HR(context9, E_OUTOFMEMORY, "Failed to lock internal render target."); + } + + uint8_t *source = static_cast<uint8_t *>(lock.pBits); + int inputPitch = lock.Pitch; + + const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(desc.Format); + + gl::FormatType formatType(format, type); + + PackPixelsParams packParams; + packParams.area.x = rect.left; + packParams.area.y = rect.top; + packParams.area.width = rect.right - rect.left; + packParams.area.height = rect.bottom - rect.top; + packParams.destFormat = &GetFormatFromFormatType(format, type); + packParams.outputPitch = static_cast<GLuint>(outputPitch); + packParams.reverseRowOrder = pack.reverseRowOrder; + + PackPixels(packParams, d3dFormatInfo.info(), inputPitch, source, pixels); + + systemSurface->UnlockRect(); + SafeRelease(systemSurface); + + return angle::Result::Continue; +} + +angle::Result Framebuffer9::blitImpl(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + const gl::Rectangle *scissor, + bool blitRenderTarget, + bool blitDepth, + bool blitStencil, + GLenum filter, + const gl::Framebuffer *sourceFramebuffer) +{ + ASSERT(filter == GL_NEAREST); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + ASSERT(device); + + mRenderer->endScene(); + + Context9 *context9 = GetImplAs<Context9>(context); + + if (blitRenderTarget) + { + const gl::FramebufferAttachment *readBuffer = sourceFramebuffer->getColorAttachment(0); + ASSERT(readBuffer); + + RenderTarget9 *readRenderTarget = nullptr; + ANGLE_TRY(readBuffer->getRenderTarget(context, 0, &readRenderTarget)); + ASSERT(readRenderTarget); + + const gl::FramebufferAttachment *drawBuffer = mState.getColorAttachment(0); + ASSERT(drawBuffer); + + RenderTarget9 *drawRenderTarget = nullptr; + ANGLE_TRY( + drawBuffer->getRenderTarget(context, drawBuffer->getSamples(), &drawRenderTarget)); + ASSERT(drawRenderTarget); + + // The getSurface calls do an AddRef so save them until after no errors are possible + IDirect3DSurface9 *readSurface = readRenderTarget->getSurface(); + ASSERT(readSurface); + + IDirect3DSurface9 *drawSurface = drawRenderTarget->getSurface(); + ASSERT(drawSurface); + + gl::Extents srcSize(readRenderTarget->getWidth(), readRenderTarget->getHeight(), 1); + gl::Extents dstSize(drawRenderTarget->getWidth(), drawRenderTarget->getHeight(), 1); + + RECT srcRect; + srcRect.left = sourceArea.x; + srcRect.right = sourceArea.x + sourceArea.width; + srcRect.top = sourceArea.y; + srcRect.bottom = sourceArea.y + sourceArea.height; + + RECT dstRect; + dstRect.left = destArea.x; + dstRect.right = destArea.x + destArea.width; + dstRect.top = destArea.y; + dstRect.bottom = destArea.y + destArea.height; + + // Clip the rectangles to the scissor rectangle + if (scissor) + { + if (dstRect.left < scissor->x) + { + srcRect.left += (scissor->x - dstRect.left); + dstRect.left = scissor->x; + } + if (dstRect.top < scissor->y) + { + srcRect.top += (scissor->y - dstRect.top); + dstRect.top = scissor->y; + } + if (dstRect.right > scissor->x + scissor->width) + { + srcRect.right -= (dstRect.right - (scissor->x + scissor->width)); + dstRect.right = scissor->x + scissor->width; + } + if (dstRect.bottom > scissor->y + scissor->height) + { + srcRect.bottom -= (dstRect.bottom - (scissor->y + scissor->height)); + dstRect.bottom = scissor->y + scissor->height; + } + } + + // Clip the rectangles to the destination size + if (dstRect.left < 0) + { + srcRect.left += -dstRect.left; + dstRect.left = 0; + } + if (dstRect.right > dstSize.width) + { + srcRect.right -= (dstRect.right - dstSize.width); + dstRect.right = dstSize.width; + } + if (dstRect.top < 0) + { + srcRect.top += -dstRect.top; + dstRect.top = 0; + } + if (dstRect.bottom > dstSize.height) + { + srcRect.bottom -= (dstRect.bottom - dstSize.height); + dstRect.bottom = dstSize.height; + } + + // Clip the rectangles to the source size + if (srcRect.left < 0) + { + dstRect.left += -srcRect.left; + srcRect.left = 0; + } + if (srcRect.right > srcSize.width) + { + dstRect.right -= (srcRect.right - srcSize.width); + srcRect.right = srcSize.width; + } + if (srcRect.top < 0) + { + dstRect.top += -srcRect.top; + srcRect.top = 0; + } + if (srcRect.bottom > srcSize.height) + { + dstRect.bottom -= (srcRect.bottom - srcSize.height); + srcRect.bottom = srcSize.height; + } + + HRESULT result = + device->StretchRect(readSurface, &srcRect, drawSurface, &dstRect, D3DTEXF_NONE); + + SafeRelease(readSurface); + SafeRelease(drawSurface); + + ANGLE_TRY_HR(context9, result, "Internal blit failed."); + } + + if (blitDepth || blitStencil) + { + const gl::FramebufferAttachment *readBuffer = + sourceFramebuffer->getDepthOrStencilAttachment(); + ASSERT(readBuffer); + + RenderTarget9 *readDepthStencil = nullptr; + ANGLE_TRY(readBuffer->getRenderTarget(context, 0, &readDepthStencil)); + ASSERT(readDepthStencil); + + const gl::FramebufferAttachment *drawBuffer = mState.getDepthOrStencilAttachment(); + ASSERT(drawBuffer); + + RenderTarget9 *drawDepthStencil = nullptr; + ANGLE_TRY( + drawBuffer->getRenderTarget(context, drawBuffer->getSamples(), &drawDepthStencil)); + ASSERT(drawDepthStencil); + + // The getSurface calls do an AddRef so save them until after no errors are possible + IDirect3DSurface9 *readSurface = readDepthStencil->getSurface(); + ASSERT(readDepthStencil); + + IDirect3DSurface9 *drawSurface = drawDepthStencil->getSurface(); + ASSERT(drawDepthStencil); + + HRESULT result = + device->StretchRect(readSurface, nullptr, drawSurface, nullptr, D3DTEXF_NONE); + + SafeRelease(readSurface); + SafeRelease(drawSurface); + + ANGLE_TRY_HR(context9, result, "Internal blit failed."); + } + + return angle::Result::Continue; +} + +const gl::InternalFormat &Framebuffer9::getImplementationColorReadFormat( + const gl::Context *context) const +{ + GLenum sizedFormat = mState.getReadAttachment()->getFormat().info->sizedInternalFormat; + const d3d9::TextureFormat &textureFormat = d3d9::GetTextureFormatInfo(sizedFormat); + const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(textureFormat.renderFormat); + const angle::Format &angleFormat = angle::Format::Get(d3dFormatInfo.formatID); + return gl::GetSizedInternalFormatInfo(angleFormat.fboImplementationInternalFormat); +} + +angle::Result Framebuffer9::getSamplePosition(const gl::Context *context, + size_t index, + GLfloat *xy) const +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Framebuffer9::syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) +{ + ANGLE_TRY(FramebufferD3D::syncState(context, binding, dirtyBits, command)); + ANGLE_TRY(mRenderTargetCache.update(context, mState, dirtyBits)); + return angle::Result::Continue; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h new file mode 100644 index 0000000000..a44118ff34 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h @@ -0,0 +1,89 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Framebuffer9.h: Defines the Framebuffer9 class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_FRAMBUFFER9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_FRAMBUFFER9_H_ + +#include "libANGLE/renderer/RenderTargetCache.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ +class Renderer9; + +class Framebuffer9 : public FramebufferD3D +{ + public: + Framebuffer9(const gl::FramebufferState &data, Renderer9 *renderer); + ~Framebuffer9() override; + + angle::Result discard(const gl::Context *context, + size_t count, + const GLenum *attachments) override; + angle::Result invalidate(const gl::Context *context, + size_t count, + const GLenum *attachments) override; + angle::Result invalidateSub(const gl::Context *context, + size_t count, + const GLenum *attachments, + const gl::Rectangle &area) override; + + angle::Result getSamplePosition(const gl::Context *context, + size_t index, + GLfloat *xy) const override; + + angle::Result syncState(const gl::Context *context, + GLenum binding, + const gl::Framebuffer::DirtyBits &dirtyBits, + gl::Command command) override; + + const gl::AttachmentArray<RenderTarget9 *> &getCachedColorRenderTargets() const + { + return mRenderTargetCache.getColors(); + } + + const RenderTarget9 *getCachedDepthStencilRenderTarget() const + { + return mRenderTargetCache.getDepthStencil(); + } + + const gl::InternalFormat &getImplementationColorReadFormat( + const gl::Context *context) const override; + + private: + angle::Result clearImpl(const gl::Context *context, + const ClearParameters &clearParams) override; + + angle::Result readPixelsImpl(const gl::Context *context, + const gl::Rectangle &area, + GLenum format, + GLenum type, + size_t outputPitch, + const gl::PixelPackState &pack, + gl::Buffer *packPixels, + uint8_t *pixels) override; + + angle::Result blitImpl(const gl::Context *context, + const gl::Rectangle &sourceArea, + const gl::Rectangle &destArea, + const gl::Rectangle *scissor, + bool blitRenderTarget, + bool blitDepth, + bool blitStencil, + GLenum filter, + const gl::Framebuffer *sourceFramebuffer) override; + + Renderer9 *const mRenderer; + + RenderTargetCache<RenderTarget9> mRenderTargetCache; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_FRAMBUFFER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.cpp new file mode 100644 index 0000000000..229d54ced9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.cpp @@ -0,0 +1,907 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Image9.cpp: Implements the rx::Image9 class, which acts as the interface to +// the actual underlying surfaces of a Texture. + +#include "libANGLE/renderer/d3d/d3d9/Image9.h" + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Renderbuffer.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/copyvertex.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ + +Image9::Image9(Renderer9 *renderer) +{ + mSurface = nullptr; + mRenderer = nullptr; + + mD3DPool = D3DPOOL_SYSTEMMEM; + mD3DFormat = D3DFMT_UNKNOWN; + + mRenderer = renderer; +} + +Image9::~Image9() +{ + SafeRelease(mSurface); +} + +// static +angle::Result Image9::GenerateMip(Context9 *context9, + IDirect3DSurface9 *destSurface, + IDirect3DSurface9 *sourceSurface) +{ + D3DSURFACE_DESC destDesc; + HRESULT result = destSurface->GetDesc(&destDesc); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, + "Failed to query the source surface description for mipmap generation"); + + D3DSURFACE_DESC sourceDesc; + result = sourceSurface->GetDesc(&sourceDesc); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, + "Failed to query the destination surface description for mipmap generation"); + + ASSERT(sourceDesc.Format == destDesc.Format); + ASSERT(sourceDesc.Width == 1 || sourceDesc.Width / 2 == destDesc.Width); + ASSERT(sourceDesc.Height == 1 || sourceDesc.Height / 2 == destDesc.Height); + + const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(sourceDesc.Format); + ASSERT(d3dFormatInfo.info().mipGenerationFunction != nullptr); + + D3DLOCKED_RECT sourceLocked = {}; + result = sourceSurface->LockRect(&sourceLocked, nullptr, D3DLOCK_READONLY); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to lock the source surface for mipmap generation"); + + D3DLOCKED_RECT destLocked = {}; + result = destSurface->LockRect(&destLocked, nullptr, 0); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to lock the destination surface for mipmap generation"); + + const uint8_t *sourceData = static_cast<const uint8_t *>(sourceLocked.pBits); + uint8_t *destData = static_cast<uint8_t *>(destLocked.pBits); + + ASSERT(sourceData && destData); + + d3dFormatInfo.info().mipGenerationFunction(sourceDesc.Width, sourceDesc.Height, 1, sourceData, + sourceLocked.Pitch, 0, destData, destLocked.Pitch, + 0); + + destSurface->UnlockRect(); + sourceSurface->UnlockRect(); + + return angle::Result::Continue; +} + +// static +angle::Result Image9::GenerateMipmap(Context9 *context9, Image9 *dest, Image9 *source) +{ + IDirect3DSurface9 *sourceSurface = nullptr; + ANGLE_TRY(source->getSurface(context9, &sourceSurface)); + + IDirect3DSurface9 *destSurface = nullptr; + ANGLE_TRY(dest->getSurface(context9, &destSurface)); + + ANGLE_TRY(GenerateMip(context9, destSurface, sourceSurface)); + + dest->markDirty(); + + return angle::Result::Continue; +} + +// static +angle::Result Image9::CopyLockableSurfaces(Context9 *context9, + IDirect3DSurface9 *dest, + IDirect3DSurface9 *source) +{ + D3DLOCKED_RECT sourceLock = {}; + D3DLOCKED_RECT destLock = {}; + + HRESULT result; + + result = source->LockRect(&sourceLock, nullptr, 0); + ANGLE_TRY_HR(context9, result, "Failed to lock source surface for copy"); + + result = dest->LockRect(&destLock, nullptr, 0); + if (FAILED(result)) + { + source->UnlockRect(); + } + ANGLE_TRY_HR(context9, result, "Failed to lock destination surface for copy"); + + ASSERT(sourceLock.pBits && destLock.pBits); + + D3DSURFACE_DESC desc; + source->GetDesc(&desc); + + const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(desc.Format); + unsigned int rows = desc.Height / d3dFormatInfo.blockHeight; + + unsigned int bytes = d3d9::ComputeBlockSize(desc.Format, desc.Width, d3dFormatInfo.blockHeight); + ASSERT(bytes <= static_cast<unsigned int>(sourceLock.Pitch) && + bytes <= static_cast<unsigned int>(destLock.Pitch)); + + for (unsigned int i = 0; i < rows; i++) + { + memcpy((char *)destLock.pBits + destLock.Pitch * i, + (char *)sourceLock.pBits + sourceLock.Pitch * i, bytes); + } + + source->UnlockRect(); + dest->UnlockRect(); + + return angle::Result::Continue; +} + +// static +angle::Result Image9::CopyImage(const gl::Context *context, + Image9 *dest, + Image9 *source, + const gl::Rectangle &sourceRect, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + Context9 *context9 = GetImplAs<Context9>(context); + + IDirect3DSurface9 *sourceSurface = nullptr; + ANGLE_TRY(source->getSurface(context9, &sourceSurface)); + + IDirect3DSurface9 *destSurface = nullptr; + ANGLE_TRY(dest->getSurface(context9, &destSurface)); + + D3DSURFACE_DESC destDesc; + HRESULT result = destSurface->GetDesc(&destDesc); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to query the source surface description for CopyImage"); + const d3d9::D3DFormat &destD3DFormatInfo = d3d9::GetD3DFormatInfo(destDesc.Format); + + D3DSURFACE_DESC sourceDesc; + result = sourceSurface->GetDesc(&sourceDesc); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, + "Failed to query the destination surface description for CopyImage"); + const d3d9::D3DFormat &sourceD3DFormatInfo = d3d9::GetD3DFormatInfo(sourceDesc.Format); + + D3DLOCKED_RECT sourceLocked = {}; + result = sourceSurface->LockRect(&sourceLocked, nullptr, D3DLOCK_READONLY); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to lock the source surface for CopyImage"); + + D3DLOCKED_RECT destLocked = {}; + result = destSurface->LockRect(&destLocked, nullptr, 0); + ASSERT(SUCCEEDED(result)); + if (FAILED(result)) + { + sourceSurface->UnlockRect(); + } + ANGLE_TRY_HR(context9, result, "Failed to lock the destination surface for CopyImage"); + + const uint8_t *sourceData = static_cast<const uint8_t *>(sourceLocked.pBits) + + sourceRect.x * sourceD3DFormatInfo.pixelBytes + + sourceRect.y * sourceLocked.Pitch; + uint8_t *destData = static_cast<uint8_t *>(destLocked.pBits) + + destOffset.x * destD3DFormatInfo.pixelBytes + + destOffset.y * destLocked.Pitch; + ASSERT(sourceData && destData); + + CopyImageCHROMIUM(sourceData, sourceLocked.Pitch, sourceD3DFormatInfo.pixelBytes, 0, + sourceD3DFormatInfo.info().pixelReadFunction, destData, destLocked.Pitch, + destD3DFormatInfo.pixelBytes, 0, destD3DFormatInfo.info().pixelWriteFunction, + gl::GetUnsizedFormat(dest->getInternalFormat()), + destD3DFormatInfo.info().componentType, sourceRect.width, sourceRect.height, + 1, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + + dest->markDirty(); + + destSurface->UnlockRect(); + sourceSurface->UnlockRect(); + + return angle::Result::Continue; +} + +bool Image9::redefine(gl::TextureType type, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) +{ + // 3D textures are not supported by the D3D9 backend. + ASSERT(size.depth <= 1); + + // Only 2D and cube texture are supported by the D3D9 backend. + ASSERT(type == gl::TextureType::_2D || type == gl::TextureType::CubeMap); + + if (mWidth != size.width || mHeight != size.height || mDepth != size.depth || + mInternalFormat != internalformat || forceRelease) + { + mWidth = size.width; + mHeight = size.height; + mDepth = size.depth; + mType = type; + mInternalFormat = internalformat; + + // compute the d3d format that will be used + const d3d9::TextureFormat &d3d9FormatInfo = d3d9::GetTextureFormatInfo(internalformat); + mD3DFormat = d3d9FormatInfo.texFormat; + mRenderable = (d3d9FormatInfo.renderFormat != D3DFMT_UNKNOWN); + + SafeRelease(mSurface); + mDirty = (d3d9FormatInfo.dataInitializerFunction != nullptr); + + return true; + } + + return false; +} + +angle::Result Image9::createSurface(Context9 *context9) +{ + if (mSurface) + { + return angle::Result::Continue; + } + + IDirect3DTexture9 *newTexture = nullptr; + IDirect3DSurface9 *newSurface = nullptr; + const D3DPOOL poolToUse = D3DPOOL_SYSTEMMEM; + const D3DFORMAT d3dFormat = getD3DFormat(); + + if (mWidth != 0 && mHeight != 0) + { + int levelToFetch = 0; + GLsizei requestWidth = mWidth; + GLsizei requestHeight = mHeight; + d3d9::MakeValidSize(true, d3dFormat, &requestWidth, &requestHeight, &levelToFetch); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + HRESULT result = device->CreateTexture(requestWidth, requestHeight, levelToFetch + 1, 0, + d3dFormat, poolToUse, &newTexture, nullptr); + + ANGLE_TRY_HR(context9, result, "Failed to create image surface"); + + newTexture->GetSurfaceLevel(levelToFetch, &newSurface); + SafeRelease(newTexture); + + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(mInternalFormat); + if (d3dFormatInfo.dataInitializerFunction != nullptr) + { + RECT entireRect; + entireRect.left = 0; + entireRect.right = mWidth; + entireRect.top = 0; + entireRect.bottom = mHeight; + + D3DLOCKED_RECT lockedRect; + result = newSurface->LockRect(&lockedRect, &entireRect, 0); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to lock image surface"); + + d3dFormatInfo.dataInitializerFunction( + mWidth, mHeight, 1, static_cast<uint8_t *>(lockedRect.pBits), lockedRect.Pitch, 0); + + result = newSurface->UnlockRect(); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to unlock image surface"); + } + } + + mSurface = newSurface; + mDirty = false; + mD3DPool = poolToUse; + + return angle::Result::Continue; +} + +angle::Result Image9::lock(Context9 *context9, D3DLOCKED_RECT *lockedRect, const RECT &rect) +{ + ANGLE_TRY(createSurface(context9)); + + if (mSurface) + { + HRESULT result = mSurface->LockRect(lockedRect, &rect, 0); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to lock image surface"); + mDirty = true; + } + + return angle::Result::Continue; +} + +void Image9::unlock() +{ + if (mSurface) + { + HRESULT result = mSurface->UnlockRect(); + ASSERT(SUCCEEDED(result)); + } +} + +D3DFORMAT Image9::getD3DFormat() const +{ + // this should only happen if the image hasn't been redefined first + // which would be a bug by the caller + ASSERT(mD3DFormat != D3DFMT_UNKNOWN); + + return mD3DFormat; +} + +bool Image9::isDirty() const +{ + // Make sure to that this image is marked as dirty even if the staging texture hasn't been + // created yet if initialization is required before use. + return (mSurface || + d3d9::GetTextureFormatInfo(mInternalFormat).dataInitializerFunction != nullptr) && + mDirty; +} + +angle::Result Image9::getSurface(Context9 *context9, IDirect3DSurface9 **outSurface) +{ + ANGLE_TRY(createSurface(context9)); + *outSurface = mSurface; + return angle::Result::Continue; +} + +angle::Result Image9::setManagedSurface2D(const gl::Context *context, + TextureStorage *storage, + int level) +{ + IDirect3DSurface9 *surface = nullptr; + TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage); + ANGLE_TRY(storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, false, &surface)); + return setManagedSurface(GetImplAs<Context9>(context), surface); +} + +angle::Result Image9::setManagedSurfaceCube(const gl::Context *context, + TextureStorage *storage, + int face, + int level) +{ + IDirect3DSurface9 *surface = nullptr; + TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage); + ANGLE_TRY(storage9->getSurfaceLevel(context, gl::CubeFaceIndexToTextureTarget(face), level, + false, &surface)); + return setManagedSurface(GetImplAs<Context9>(context), surface); +} + +angle::Result Image9::setManagedSurface(Context9 *context9, IDirect3DSurface9 *surface) +{ + D3DSURFACE_DESC desc; + surface->GetDesc(&desc); + ASSERT(desc.Pool == D3DPOOL_MANAGED); + + if ((GLsizei)desc.Width == mWidth && (GLsizei)desc.Height == mHeight) + { + if (mSurface) + { + angle::Result result = CopyLockableSurfaces(context9, surface, mSurface); + SafeRelease(mSurface); + ANGLE_TRY(result); + } + + mSurface = surface; + mD3DPool = desc.Pool; + } + + return angle::Result::Continue; +} + +angle::Result Image9::copyToStorage(const gl::Context *context, + TextureStorage *storage, + const gl::ImageIndex &index, + const gl::Box ®ion) +{ + ANGLE_TRY(createSurface(GetImplAs<Context9>(context))); + + TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage); + IDirect3DSurface9 *destSurface = nullptr; + ANGLE_TRY(storage9->getSurfaceLevel(context, index.getTarget(), index.getLevelIndex(), true, + &destSurface)); + + angle::Result result = copyToSurface(GetImplAs<Context9>(context), destSurface, region); + SafeRelease(destSurface); + return result; +} + +angle::Result Image9::copyToSurface(Context9 *context9, + IDirect3DSurface9 *destSurface, + const gl::Box &area) +{ + ASSERT(area.width > 0 && area.height > 0 && area.depth == 1); + ASSERT(destSurface); + + IDirect3DSurface9 *sourceSurface = nullptr; + ANGLE_TRY(getSurface(context9, &sourceSurface)); + + ASSERT(sourceSurface && sourceSurface != destSurface); + + RECT rect; + rect.left = area.x; + rect.top = area.y; + rect.right = area.x + area.width; + rect.bottom = area.y + area.height; + + POINT point = {rect.left, rect.top}; + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + if (mD3DPool == D3DPOOL_MANAGED) + { + D3DSURFACE_DESC desc; + sourceSurface->GetDesc(&desc); + + IDirect3DSurface9 *surf = 0; + HRESULT result = device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, + D3DPOOL_SYSTEMMEM, &surf, nullptr); + ANGLE_TRY_HR(context9, result, "Internal CreateOffscreenPlainSurface call failed"); + + auto err = CopyLockableSurfaces(context9, surf, sourceSurface); + result = device->UpdateSurface(surf, &rect, destSurface, &point); + SafeRelease(surf); + ANGLE_TRY(err); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Internal UpdateSurface call failed"); + } + else + { + // UpdateSurface: source must be SYSTEMMEM, dest must be DEFAULT pools + HRESULT result = device->UpdateSurface(sourceSurface, &rect, destSurface, &point); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Internal UpdateSurface call failed"); + } + + return angle::Result::Continue; +} + +// Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as +// format/type at input into the target pixel rectangle. +angle::Result Image9::loadData(const gl::Context *context, + const gl::Box &area, + const gl::PixelUnpackState &unpack, + GLenum type, + const void *input, + bool applySkipImages) +{ + // 3D textures are not supported by the D3D9 backend. + ASSERT(area.z == 0 && area.depth == 1); + + Context9 *context9 = GetImplAs<Context9>(context); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat); + GLuint inputRowPitch = 0; + ANGLE_CHECK_GL_MATH(context9, formatInfo.computeRowPitch(type, area.width, unpack.alignment, + unpack.rowLength, &inputRowPitch)); + ASSERT(!applySkipImages); + ASSERT(unpack.skipPixels == 0); + ASSERT(unpack.skipRows == 0); + + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(mInternalFormat); + ASSERT(d3dFormatInfo.loadFunction != nullptr); + + RECT lockRect = {area.x, area.y, area.x + area.width, area.y + area.height}; + + D3DLOCKED_RECT locked; + ANGLE_TRY(lock(GetImplAs<Context9>(context), &locked, lockRect)); + + d3dFormatInfo.loadFunction(area.width, area.height, area.depth, + static_cast<const uint8_t *>(input), inputRowPitch, 0, + static_cast<uint8_t *>(locked.pBits), locked.Pitch, 0); + + unlock(); + + return angle::Result::Continue; +} + +angle::Result Image9::loadCompressedData(const gl::Context *context, + const gl::Box &area, + const void *input) +{ + // 3D textures are not supported by the D3D9 backend. + ASSERT(area.z == 0 && area.depth == 1); + + Context9 *context9 = GetImplAs<Context9>(context); + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat); + GLuint inputRowPitch = 0; + ANGLE_CHECK_GL_MATH( + context9, formatInfo.computeRowPitch(GL_UNSIGNED_BYTE, area.width, 1, 0, &inputRowPitch)); + + GLuint inputDepthPitch = 0; + ANGLE_CHECK_GL_MATH( + context9, formatInfo.computeDepthPitch(area.height, 0, inputRowPitch, &inputDepthPitch)); + + const d3d9::TextureFormat &d3d9FormatInfo = d3d9::GetTextureFormatInfo(mInternalFormat); + + ASSERT(area.x % d3d9::GetD3DFormatInfo(d3d9FormatInfo.texFormat).blockWidth == 0); + ASSERT(area.y % d3d9::GetD3DFormatInfo(d3d9FormatInfo.texFormat).blockHeight == 0); + + ASSERT(d3d9FormatInfo.loadFunction != nullptr); + + RECT lockRect = {area.x, area.y, area.x + area.width, area.y + area.height}; + + D3DLOCKED_RECT locked; + ANGLE_TRY(lock(GetImplAs<Context9>(context), &locked, lockRect)); + + d3d9FormatInfo.loadFunction(area.width, area.height, area.depth, + static_cast<const uint8_t *>(input), inputRowPitch, inputDepthPitch, + static_cast<uint8_t *>(locked.pBits), locked.Pitch, 0); + + unlock(); + + return angle::Result::Continue; +} + +// This implements glCopyTex[Sub]Image2D for non-renderable internal texture formats and incomplete +// textures +angle::Result Image9::copyFromRTInternal(Context9 *context9, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + RenderTargetD3D *source) +{ + ASSERT(source); + + // ES3.0 only behaviour to copy into a 3d texture + ASSERT(destOffset.z == 0); + + RenderTarget9 *renderTarget = GetAs<RenderTarget9>(source); + + angle::ComPtr<IDirect3DSurface9> surface = renderTarget->getSurface(); + ASSERT(surface); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + angle::ComPtr<IDirect3DSurface9> renderTargetData = nullptr; + D3DSURFACE_DESC description; + surface->GetDesc(&description); + + HRESULT hr = device->CreateOffscreenPlainSurface(description.Width, description.Height, + description.Format, D3DPOOL_SYSTEMMEM, + &renderTargetData, nullptr); + + ANGLE_TRY_HR(context9, hr, "Could not create matching destination surface"); + + hr = device->GetRenderTargetData(surface.Get(), renderTargetData.Get()); + + ANGLE_TRY_HR(context9, hr, "GetRenderTargetData unexpectedly failed"); + + int width = sourceArea.width; + int height = sourceArea.height; + + RECT sourceRect = {sourceArea.x, sourceArea.y, sourceArea.x + width, sourceArea.y + height}; + RECT destRect = {destOffset.x, destOffset.y, destOffset.x + width, destOffset.y + height}; + + D3DLOCKED_RECT sourceLock = {}; + hr = renderTargetData->LockRect(&sourceLock, &sourceRect, 0); + + ANGLE_TRY_HR(context9, hr, "Failed to lock the source surface (rectangle might be invalid)"); + + D3DLOCKED_RECT destLock = {}; + angle::Result result = lock(context9, &destLock, destRect); + if (result == angle::Result::Stop) + { + renderTargetData->UnlockRect(); + } + ANGLE_TRY(result); + + ASSERT(destLock.pBits && sourceLock.pBits); + + unsigned char *sourcePixels = (unsigned char *)sourceLock.pBits; + unsigned char *destPixels = (unsigned char *)destLock.pBits; + + switch (description.Format) + { + case D3DFMT_X8R8G8B8: + case D3DFMT_A8R8G8B8: + switch (getD3DFormat()) + { + case D3DFMT_X8R8G8B8: + case D3DFMT_A8R8G8B8: + for (int y = 0; y < height; y++) + { + memcpy(destPixels, sourcePixels, 4 * width); + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_L8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + destPixels[x] = sourcePixels[x * 4 + 2]; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_A8L8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + destPixels[x * 2 + 0] = sourcePixels[x * 4 + 2]; + destPixels[x * 2 + 1] = sourcePixels[x * 4 + 3]; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + default: + UNREACHABLE(); + } + break; + case D3DFMT_R5G6B5: + switch (getD3DFormat()) + { + case D3DFMT_X8R8G8B8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned short rgb = ((unsigned short *)sourcePixels)[x]; + unsigned char red = static_cast<unsigned char>((rgb & 0xF800) >> 8); + unsigned char green = static_cast<unsigned char>((rgb & 0x07E0) >> 3); + unsigned char blue = static_cast<unsigned char>((rgb & 0x001F) << 3); + destPixels[x + 0] = blue | (blue >> 5); + destPixels[x + 1] = green | (green >> 6); + destPixels[x + 2] = red | (red >> 5); + destPixels[x + 3] = 0xFF; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_L8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned char red = sourcePixels[x * 2 + 1] & 0xF8; + destPixels[x] = red | (red >> 5); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + default: + UNREACHABLE(); + } + break; + case D3DFMT_A1R5G5B5: + switch (getD3DFormat()) + { + case D3DFMT_X8R8G8B8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned short argb = ((unsigned short *)sourcePixels)[x]; + unsigned char red = static_cast<unsigned char>((argb & 0x7C00) >> 7); + unsigned char green = static_cast<unsigned char>((argb & 0x03E0) >> 2); + unsigned char blue = static_cast<unsigned char>((argb & 0x001F) << 3); + destPixels[x + 0] = blue | (blue >> 5); + destPixels[x + 1] = green | (green >> 5); + destPixels[x + 2] = red | (red >> 5); + destPixels[x + 3] = 0xFF; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_A8R8G8B8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned short argb = ((unsigned short *)sourcePixels)[x]; + unsigned char red = static_cast<unsigned char>((argb & 0x7C00) >> 7); + unsigned char green = static_cast<unsigned char>((argb & 0x03E0) >> 2); + unsigned char blue = static_cast<unsigned char>((argb & 0x001F) << 3); + unsigned char alpha = (signed short)argb >> 15; + destPixels[x + 0] = blue | (blue >> 5); + destPixels[x + 1] = green | (green >> 5); + destPixels[x + 2] = red | (red >> 5); + destPixels[x + 3] = alpha; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_L8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned char red = sourcePixels[x * 2 + 1] & 0x7C; + destPixels[x] = (red << 1) | (red >> 4); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_A8L8: + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + unsigned char red = sourcePixels[x * 2 + 1] & 0x7C; + destPixels[x * 2 + 0] = (red << 1) | (red >> 4); + destPixels[x * 2 + 1] = (signed char)sourcePixels[x * 2 + 1] >> 7; + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + default: + UNREACHABLE(); + } + break; + case D3DFMT_A16B16G16R16F: + switch (getD3DFormat()) + { + case D3DFMT_X8R8G8B8: + case D3DFMT_A8R8G8B8: + for (int y = 0; y < height; y++) + { + const uint16_t *sourcePixels16F = + reinterpret_cast<uint16_t *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = gl::float16ToFloat32(sourcePixels16F[x * 4 + 0]); + float g = gl::float16ToFloat32(sourcePixels16F[x * 4 + 1]); + float b = gl::float16ToFloat32(sourcePixels16F[x * 4 + 2]); + float a = gl::float16ToFloat32(sourcePixels16F[x * 4 + 3]); + destPixels[x * 4 + 0] = gl::floatToNormalized<uint8_t>(b); + destPixels[x * 4 + 1] = gl::floatToNormalized<uint8_t>(g); + destPixels[x * 4 + 2] = gl::floatToNormalized<uint8_t>(r); + destPixels[x * 4 + 3] = gl::floatToNormalized<uint8_t>(a); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_L8: + for (int y = 0; y < height; y++) + { + const uint16_t *sourcePixels16F = + reinterpret_cast<uint16_t *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = gl::float16ToFloat32(sourcePixels16F[x * 4]); + destPixels[x] = gl::floatToNormalized<uint8_t>(r); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_A8L8: + for (int y = 0; y < height; y++) + { + const uint16_t *sourcePixels16F = + reinterpret_cast<uint16_t *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = gl::float16ToFloat32(sourcePixels16F[x * 4 + 0]); + float a = gl::float16ToFloat32(sourcePixels16F[x * 4 + 3]); + destPixels[x * 2 + 0] = gl::floatToNormalized<uint8_t>(r); + destPixels[x * 2 + 1] = gl::floatToNormalized<uint8_t>(a); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + default: + UNREACHABLE(); + } + break; + case D3DFMT_A32B32G32R32F: + switch (getD3DFormat()) + { + case D3DFMT_X8R8G8B8: + case D3DFMT_A8R8G8B8: + for (int y = 0; y < height; y++) + { + const float *sourcePixels32F = reinterpret_cast<float *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = sourcePixels32F[x * 4 + 0]; + float g = sourcePixels32F[x * 4 + 1]; + float b = sourcePixels32F[x * 4 + 2]; + float a = sourcePixels32F[x * 4 + 3]; + destPixels[x * 4 + 0] = gl::floatToNormalized<uint8_t>(b); + destPixels[x * 4 + 1] = gl::floatToNormalized<uint8_t>(g); + destPixels[x * 4 + 2] = gl::floatToNormalized<uint8_t>(r); + destPixels[x * 4 + 3] = gl::floatToNormalized<uint8_t>(a); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_L8: + for (int y = 0; y < height; y++) + { + const float *sourcePixels32F = reinterpret_cast<float *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = sourcePixels32F[x * 4]; + destPixels[x] = gl::floatToNormalized<uint8_t>(r); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + case D3DFMT_A8L8: + for (int y = 0; y < height; y++) + { + const float *sourcePixels32F = reinterpret_cast<float *>(sourcePixels); + for (int x = 0; x < width; x++) + { + float r = sourcePixels32F[x * 4 + 0]; + float a = sourcePixels32F[x * 4 + 3]; + destPixels[x * 2 + 0] = gl::floatToNormalized<uint8_t>(r); + destPixels[x * 2 + 1] = gl::floatToNormalized<uint8_t>(a); + } + sourcePixels += sourceLock.Pitch; + destPixels += destLock.Pitch; + } + break; + default: + UNREACHABLE(); + } + break; + default: + UNREACHABLE(); + } + + unlock(); + renderTargetData->UnlockRect(); + + mDirty = true; + return angle::Result::Continue; +} + +angle::Result Image9::copyFromTexStorage(const gl::Context *context, + const gl::ImageIndex &imageIndex, + TextureStorage *source) +{ + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(source->getRenderTarget(context, imageIndex, 0, &renderTarget)); + + gl::Rectangle sourceArea(0, 0, mWidth, mHeight); + return copyFromRTInternal(GetImplAs<Context9>(context), gl::Offset(), sourceArea, renderTarget); +} + +angle::Result Image9::copyFromFramebuffer(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + const gl::Framebuffer *source) +{ + const gl::FramebufferAttachment *srcAttachment = source->getReadColorAttachment(); + ASSERT(srcAttachment); + + RenderTargetD3D *renderTarget = nullptr; + ANGLE_TRY(srcAttachment->getRenderTarget(context, 0, &renderTarget)); + ASSERT(renderTarget); + return copyFromRTInternal(GetImplAs<Context9>(context), destOffset, sourceArea, renderTarget); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.h new file mode 100644 index 0000000000..80064aa24b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Image9.h @@ -0,0 +1,112 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Image9.h: Defines the rx::Image9 class, which acts as the interface to +// the actual underlying surfaces of a Texture. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_ + +#include "common/debug.h" +#include "libANGLE/renderer/d3d/ImageD3D.h" + +namespace gl +{ +class Framebuffer; +} + +namespace rx +{ +class Context9; +class Renderer9; + +class Image9 : public ImageD3D +{ + public: + Image9(Renderer9 *renderer); + ~Image9() override; + + static angle::Result GenerateMipmap(Context9 *context9, Image9 *dest, Image9 *source); + static angle::Result GenerateMip(Context9 *context9, + IDirect3DSurface9 *destSurface, + IDirect3DSurface9 *sourceSurface); + static angle::Result CopyLockableSurfaces(Context9 *context9, + IDirect3DSurface9 *dest, + IDirect3DSurface9 *source); + static angle::Result CopyImage(const gl::Context *context, + Image9 *dest, + Image9 *source, + const gl::Rectangle &sourceRect, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha); + + bool redefine(gl::TextureType type, + GLenum internalformat, + const gl::Extents &size, + bool forceRelease) override; + + D3DFORMAT getD3DFormat() const; + + bool isDirty() const override; + + angle::Result setManagedSurface2D(const gl::Context *context, + TextureStorage *storage, + int level) override; + angle::Result setManagedSurfaceCube(const gl::Context *context, + TextureStorage *storage, + int face, + int level) override; + angle::Result copyToStorage(const gl::Context *context, + TextureStorage *storage, + const gl::ImageIndex &index, + const gl::Box ®ion) override; + + angle::Result loadData(const gl::Context *context, + const gl::Box &area, + const gl::PixelUnpackState &unpack, + GLenum type, + const void *input, + bool applySkipImages) override; + angle::Result loadCompressedData(const gl::Context *context, + const gl::Box &area, + const void *input) override; + + angle::Result copyFromTexStorage(const gl::Context *context, + const gl::ImageIndex &imageIndex, + TextureStorage *source) override; + angle::Result copyFromFramebuffer(const gl::Context *context, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + const gl::Framebuffer *source) override; + + private: + angle::Result getSurface(Context9 *context9, IDirect3DSurface9 **outSurface); + + angle::Result createSurface(Context9 *context9); + angle::Result setManagedSurface(Context9 *context9, IDirect3DSurface9 *surface); + angle::Result copyToSurface(Context9 *context9, IDirect3DSurface9 *dest, const gl::Box &area); + + angle::Result lock(Context9 *context9, D3DLOCKED_RECT *lockedRect, const RECT &rect); + void unlock(); + + angle::Result copyFromRTInternal(Context9 *context9, + const gl::Offset &destOffset, + const gl::Rectangle &sourceArea, + RenderTargetD3D *source); + + Renderer9 *mRenderer; + + D3DPOOL mD3DPool; // can only be D3DPOOL_SYSTEMMEM or D3DPOOL_MANAGED since it needs to be + // lockable. + D3DFORMAT mD3DFormat; + + IDirect3DSurface9 *mSurface; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_IMAGE9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp new file mode 100644 index 0000000000..26bae3bdb8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp @@ -0,0 +1,161 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Indexffer9.cpp: Defines the D3D9 IndexBuffer implementation. + +#include "libANGLE/renderer/d3d/d3d9/IndexBuffer9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" + +namespace rx +{ + +IndexBuffer9::IndexBuffer9(Renderer9 *const renderer) : mRenderer(renderer) +{ + mIndexBuffer = nullptr; + mBufferSize = 0; + mIndexType = gl::DrawElementsType::InvalidEnum; + mDynamic = false; +} + +IndexBuffer9::~IndexBuffer9() +{ + SafeRelease(mIndexBuffer); +} + +angle::Result IndexBuffer9::initialize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType, + bool dynamic) +{ + SafeRelease(mIndexBuffer); + + updateSerial(); + + if (bufferSize > 0) + { + D3DFORMAT format = D3DFMT_UNKNOWN; + if (indexType == gl::DrawElementsType::UnsignedShort || + indexType == gl::DrawElementsType::UnsignedByte) + { + format = D3DFMT_INDEX16; + } + else if (indexType == gl::DrawElementsType::UnsignedInt) + { + ASSERT(mRenderer->getNativeExtensions().elementIndexUintOES); + format = D3DFMT_INDEX32; + } + else + UNREACHABLE(); + + DWORD usageFlags = D3DUSAGE_WRITEONLY; + if (dynamic) + { + usageFlags |= D3DUSAGE_DYNAMIC; + } + + HRESULT result = + mRenderer->createIndexBuffer(bufferSize, usageFlags, format, &mIndexBuffer); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, + "Failed to allocate internal index buffer"); + } + + mBufferSize = bufferSize; + mIndexType = indexType; + mDynamic = dynamic; + + return angle::Result::Continue; +} + +angle::Result IndexBuffer9::mapBuffer(const gl::Context *context, + unsigned int offset, + unsigned int size, + void **outMappedMemory) +{ + ASSERT(mIndexBuffer); + + DWORD lockFlags = mDynamic ? D3DLOCK_NOOVERWRITE : 0; + + void *mapPtr = nullptr; + HRESULT result = mIndexBuffer->Lock(offset, size, &mapPtr, lockFlags); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to lock internal index buffer"); + + *outMappedMemory = mapPtr; + return angle::Result::Continue; +} + +angle::Result IndexBuffer9::unmapBuffer(const gl::Context *context) +{ + ASSERT(mIndexBuffer); + HRESULT result = mIndexBuffer->Unlock(); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to unlock internal index buffer"); + + return angle::Result::Continue; +} + +gl::DrawElementsType IndexBuffer9::getIndexType() const +{ + return mIndexType; +} + +unsigned int IndexBuffer9::getBufferSize() const +{ + return mBufferSize; +} + +angle::Result IndexBuffer9::setSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) +{ + if (bufferSize > mBufferSize || indexType != mIndexType) + { + return initialize(context, bufferSize, indexType, mDynamic); + } + + return angle::Result::Continue; +} + +angle::Result IndexBuffer9::discard(const gl::Context *context) +{ + ASSERT(mIndexBuffer); + + void *mock; + HRESULT result; + + Context9 *context9 = GetImplAs<Context9>(context); + + result = mIndexBuffer->Lock(0, 1, &mock, D3DLOCK_DISCARD); + ANGLE_TRY_HR(context9, result, "Failed to lock internal index buffer"); + + result = mIndexBuffer->Unlock(); + ANGLE_TRY_HR(context9, result, "Failed to unlock internal index buffer"); + + return angle::Result::Continue; +} + +D3DFORMAT IndexBuffer9::getIndexFormat() const +{ + switch (mIndexType) + { + case gl::DrawElementsType::UnsignedByte: + return D3DFMT_INDEX16; + case gl::DrawElementsType::UnsignedShort: + return D3DFMT_INDEX16; + case gl::DrawElementsType::UnsignedInt: + return D3DFMT_INDEX32; + default: + UNREACHABLE(); + return D3DFMT_UNKNOWN; + } +} + +IDirect3DIndexBuffer9 *IndexBuffer9::getBuffer() const +{ + return mIndexBuffer; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.h new file mode 100644 index 0000000000..9493a1ebbe --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.h @@ -0,0 +1,57 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Indexffer9.h: Defines the D3D9 IndexBuffer implementation. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_INDEXBUFFER9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_INDEXBUFFER9_H_ + +#include "libANGLE/renderer/d3d/IndexBuffer.h" + +namespace rx +{ +class Renderer9; + +class IndexBuffer9 : public IndexBuffer +{ + public: + explicit IndexBuffer9(Renderer9 *const renderer); + ~IndexBuffer9() override; + + angle::Result initialize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType, + bool dynamic) override; + + angle::Result mapBuffer(const gl::Context *context, + unsigned int offset, + unsigned int size, + void **outMappedMemory) override; + angle::Result unmapBuffer(const gl::Context *context) override; + + gl::DrawElementsType getIndexType() const override; + unsigned int getBufferSize() const override; + angle::Result setSize(const gl::Context *context, + unsigned int bufferSize, + gl::DrawElementsType indexType) override; + + angle::Result discard(const gl::Context *context) override; + + D3DFORMAT getIndexFormat() const; + IDirect3DIndexBuffer9 *getBuffer() const; + + private: + Renderer9 *const mRenderer; + + IDirect3DIndexBuffer9 *mIndexBuffer; + unsigned int mBufferSize; + gl::DrawElementsType mIndexType; + bool mDynamic; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_INDEXBUFFER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.cpp new file mode 100644 index 0000000000..e4834b44eb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.cpp @@ -0,0 +1,37 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindow9.cpp: Defines NativeWindow9, a class for managing and +// performing operations on an EGLNativeWindowType for the D3D9 renderer. + +#include "libANGLE/renderer/d3d/d3d9/NativeWindow9.h" + +namespace rx +{ +NativeWindow9::NativeWindow9(EGLNativeWindowType window) : NativeWindowD3D(window) {} + +bool NativeWindow9::initialize() +{ + return true; +} + +bool NativeWindow9::getClientRect(LPRECT rect) const +{ + return GetClientRect(getNativeWindow(), rect) == TRUE; +} + +bool NativeWindow9::isIconic() const +{ + return IsIconic(getNativeWindow()) == TRUE; +} + +// static +bool NativeWindow9::IsValidNativeWindow(EGLNativeWindowType window) +{ + return IsWindow(window) == TRUE; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.h new file mode 100644 index 0000000000..aae9e13cc0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/NativeWindow9.h @@ -0,0 +1,35 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// NativeWindow9.h: Defines NativeWindow9, a class for managing and +// performing operations on an EGLNativeWindowType for the D3D9 renderer. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_NATIVEWINDOW9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_NATIVEWINDOW9_H_ + +#include "common/debug.h" +#include "common/platform.h" + +#include "libANGLE/renderer/d3d/NativeWindowD3D.h" + +namespace rx +{ + +class NativeWindow9 : public NativeWindowD3D +{ + public: + explicit NativeWindow9(EGLNativeWindowType window); + + bool initialize() override; + bool getClientRect(LPRECT rect) const override; + bool isIconic() const override; + + static bool IsValidNativeWindow(EGLNativeWindowType window); +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_NATIVEWINDOW9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.cpp new file mode 100644 index 0000000000..aeefd6a29f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.cpp @@ -0,0 +1,176 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Query9.cpp: Defines the rx::Query9 class which implements rx::QueryImpl. + +#include "libANGLE/renderer/d3d/d3d9/Query9.h" + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +#include <GLES2/gl2ext.h> + +namespace rx +{ +Query9::Query9(Renderer9 *renderer, gl::QueryType type) + : QueryImpl(type), + mGetDataAttemptCount(0), + mResult(GL_FALSE), + mQueryFinished(false), + mRenderer(renderer), + mQuery(nullptr) +{} + +Query9::~Query9() +{ + SafeRelease(mQuery); +} + +angle::Result Query9::begin(const gl::Context *context) +{ + Context9 *context9 = GetImplAs<Context9>(context); + + D3DQUERYTYPE d3dQueryType = gl_d3d9::ConvertQueryType(getType()); + if (mQuery == nullptr) + { + HRESULT result = mRenderer->getDevice()->CreateQuery(d3dQueryType, &mQuery); + ANGLE_TRY_HR(context9, result, "Internal query creation failed"); + } + + if (d3dQueryType != D3DQUERYTYPE_EVENT) + { + HRESULT result = mQuery->Issue(D3DISSUE_BEGIN); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to begin internal query"); + } + + return angle::Result::Continue; +} + +angle::Result Query9::end(const gl::Context *context) +{ + Context9 *context9 = GetImplAs<Context9>(context); + ASSERT(mQuery); + + HRESULT result = mQuery->Issue(D3DISSUE_END); + ASSERT(SUCCEEDED(result)); + ANGLE_TRY_HR(context9, result, "Failed to end internal query"); + mQueryFinished = false; + mResult = GL_FALSE; + + return angle::Result::Continue; +} + +angle::Result Query9::queryCounter(const gl::Context *context) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); +} + +template <typename T> +angle::Result Query9::getResultBase(Context9 *context9, T *params) +{ + while (!mQueryFinished) + { + ANGLE_TRY(testQuery(context9)); + + if (!mQueryFinished) + { + Sleep(0); + } + } + + ASSERT(mQueryFinished); + *params = static_cast<T>(mResult); + return angle::Result::Continue; +} + +angle::Result Query9::getResult(const gl::Context *context, GLint *params) +{ + return getResultBase(GetImplAs<Context9>(context), params); +} + +angle::Result Query9::getResult(const gl::Context *context, GLuint *params) +{ + return getResultBase(GetImplAs<Context9>(context), params); +} + +angle::Result Query9::getResult(const gl::Context *context, GLint64 *params) +{ + return getResultBase(GetImplAs<Context9>(context), params); +} + +angle::Result Query9::getResult(const gl::Context *context, GLuint64 *params) +{ + return getResultBase(GetImplAs<Context9>(context), params); +} + +angle::Result Query9::isResultAvailable(const gl::Context *context, bool *available) +{ + ANGLE_TRY(testQuery(GetImplAs<Context9>(context))); + *available = mQueryFinished; + return angle::Result::Continue; +} + +angle::Result Query9::testQuery(Context9 *context9) +{ + if (!mQueryFinished) + { + ASSERT(mQuery); + + HRESULT result = S_OK; + switch (getType()) + { + case gl::QueryType::AnySamples: + case gl::QueryType::AnySamplesConservative: + { + DWORD numPixels = 0; + result = mQuery->GetData(&numPixels, sizeof(numPixels), D3DGETDATA_FLUSH); + if (result == S_OK) + { + mQueryFinished = true; + mResult = (numPixels > 0) ? GL_TRUE : GL_FALSE; + } + break; + } + + case gl::QueryType::CommandsCompleted: + { + BOOL completed = FALSE; + result = mQuery->GetData(&completed, sizeof(completed), D3DGETDATA_FLUSH); + if (result == S_OK) + { + mQueryFinished = true; + mResult = (completed == TRUE) ? GL_TRUE : GL_FALSE; + } + break; + } + + default: + UNREACHABLE(); + break; + } + + if (!mQueryFinished) + { + ANGLE_TRY_HR(context9, result, "Failed to test get query result"); + + mGetDataAttemptCount++; + bool checkDeviceLost = + (mGetDataAttemptCount % kPollingD3DDeviceLostCheckFrequency) == 0; + if (checkDeviceLost && mRenderer->testDeviceLost()) + { + ANGLE_TRY_HR(context9, D3DERR_DEVICELOST, + "Failed to test get query result, device is lost"); + } + } + } + + return angle::Result::Continue; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.h new file mode 100644 index 0000000000..df10ded225 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Query9.h @@ -0,0 +1,50 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Query9.h: Defines the rx::Query9 class which implements rx::QueryImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_QUERY9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_QUERY9_H_ + +#include "libANGLE/renderer/QueryImpl.h" + +namespace rx +{ +class Context9; +class Renderer9; + +class Query9 : public QueryImpl +{ + public: + Query9(Renderer9 *renderer, gl::QueryType type); + ~Query9() override; + + angle::Result begin(const gl::Context *context) override; + angle::Result end(const gl::Context *context) override; + angle::Result queryCounter(const gl::Context *context) override; + angle::Result getResult(const gl::Context *context, GLint *params) override; + angle::Result getResult(const gl::Context *context, GLuint *params) override; + angle::Result getResult(const gl::Context *context, GLint64 *params) override; + angle::Result getResult(const gl::Context *context, GLuint64 *params) override; + angle::Result isResultAvailable(const gl::Context *context, bool *available) override; + + private: + angle::Result testQuery(Context9 *context9); + + template <typename T> + angle::Result getResultBase(Context9 *context9, T *params); + + unsigned int mGetDataAttemptCount; + GLuint64 mResult; + bool mQueryFinished; + + Renderer9 *mRenderer; + IDirect3DQuery9 *mQuery; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_QUERY9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.cpp new file mode 100644 index 0000000000..54c3291799 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.cpp @@ -0,0 +1,160 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTarget9.cpp: Implements a D3D9-specific wrapper for IDirect3DSurface9 +// pointers retained by renderbuffers. + +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/SwapChain9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ + +// TODO: AddRef the incoming surface to take ownership instead of expecting that its ref is being +// given. +TextureRenderTarget9::TextureRenderTarget9(IDirect3DBaseTexture9 *texture, + size_t textureLevel, + IDirect3DSurface9 *surface, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples) + : mWidth(width), + mHeight(height), + mDepth(depth), + mInternalFormat(internalFormat), + mD3DFormat(D3DFMT_UNKNOWN), + mSamples(samples), + mTexture(texture), + mTextureLevel(textureLevel), + mRenderTarget(surface) +{ + ASSERT(mDepth == 1); + + if (mRenderTarget) + { + D3DSURFACE_DESC description; + mRenderTarget->GetDesc(&description); + mD3DFormat = description.Format; + } +} + +TextureRenderTarget9::~TextureRenderTarget9() +{ + SafeRelease(mTexture); + SafeRelease(mRenderTarget); +} + +GLsizei TextureRenderTarget9::getWidth() const +{ + return mWidth; +} + +GLsizei TextureRenderTarget9::getHeight() const +{ + return mHeight; +} + +GLsizei TextureRenderTarget9::getDepth() const +{ + return mDepth; +} + +GLenum TextureRenderTarget9::getInternalFormat() const +{ + return mInternalFormat; +} + +GLsizei TextureRenderTarget9::getSamples() const +{ + return mSamples; +} + +IDirect3DBaseTexture9 *TextureRenderTarget9::getTexture() const +{ + return mTexture; +} + +size_t TextureRenderTarget9::getTextureLevel() const +{ + return mTextureLevel; +} + +IDirect3DSurface9 *TextureRenderTarget9::getSurface() const +{ + // Caller is responsible for releasing the returned surface reference. + // TODO: remove the AddRef to match RenderTarget11 + if (mRenderTarget) + { + mRenderTarget->AddRef(); + } + + return mRenderTarget; +} + +D3DFORMAT TextureRenderTarget9::getD3DFormat() const +{ + return mD3DFormat; +} + +SurfaceRenderTarget9::SurfaceRenderTarget9(SwapChain9 *swapChain, bool depth) + : mSwapChain(swapChain), mDepth(depth) +{} + +SurfaceRenderTarget9::~SurfaceRenderTarget9() {} + +GLsizei SurfaceRenderTarget9::getWidth() const +{ + return mSwapChain->getWidth(); +} + +GLsizei SurfaceRenderTarget9::getHeight() const +{ + return mSwapChain->getHeight(); +} + +GLsizei SurfaceRenderTarget9::getDepth() const +{ + return 1; +} + +GLenum SurfaceRenderTarget9::getInternalFormat() const +{ + return (mDepth ? mSwapChain->getDepthBufferInternalFormat() + : mSwapChain->getRenderTargetInternalFormat()); +} + +GLsizei SurfaceRenderTarget9::getSamples() const +{ + // Our EGL surfaces do not support multisampling. + return 0; +} + +IDirect3DSurface9 *SurfaceRenderTarget9::getSurface() const +{ + return (mDepth ? mSwapChain->getDepthStencil() : mSwapChain->getRenderTarget()); +} + +IDirect3DBaseTexture9 *SurfaceRenderTarget9::getTexture() const +{ + return (mDepth ? nullptr : mSwapChain->getOffscreenTexture()); +} + +size_t SurfaceRenderTarget9::getTextureLevel() const +{ + return 0; +} + +D3DFORMAT SurfaceRenderTarget9::getD3DFormat() const +{ + return d3d9::GetTextureFormatInfo(getInternalFormat()).texFormat; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.h new file mode 100644 index 0000000000..010955eb41 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/RenderTarget9.h @@ -0,0 +1,98 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// RenderTarget9.h: Defines a D3D9-specific wrapper for IDirect3DSurface9 pointers +// retained by Renderbuffers. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_RENDERTARGET9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_RENDERTARGET9_H_ + +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" + +namespace rx +{ +class Renderer9; +class SwapChain9; + +class RenderTarget9 : public RenderTargetD3D +{ + public: + RenderTarget9() {} + ~RenderTarget9() override {} + // Retrieve the texture that backs this render target, may be null for swap chain render + // targets. + virtual IDirect3DBaseTexture9 *getTexture() const = 0; + virtual size_t getTextureLevel() const = 0; + + virtual IDirect3DSurface9 *getSurface() const = 0; + + virtual D3DFORMAT getD3DFormat() const = 0; +}; + +class TextureRenderTarget9 : public RenderTarget9 +{ + public: + TextureRenderTarget9(IDirect3DBaseTexture9 *texture, + size_t textureLevel, + IDirect3DSurface9 *surface, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei samples); + ~TextureRenderTarget9() override; + + GLsizei getWidth() const override; + GLsizei getHeight() const override; + GLsizei getDepth() const override; + GLenum getInternalFormat() const override; + GLsizei getSamples() const override; + + IDirect3DBaseTexture9 *getTexture() const override; + size_t getTextureLevel() const override; + IDirect3DSurface9 *getSurface() const override; + + D3DFORMAT getD3DFormat() const override; + + private: + GLsizei mWidth; + GLsizei mHeight; + GLsizei mDepth; + GLenum mInternalFormat; + D3DFORMAT mD3DFormat; + GLsizei mSamples; + + IDirect3DBaseTexture9 *mTexture; + size_t mTextureLevel; + IDirect3DSurface9 *mRenderTarget; +}; + +class SurfaceRenderTarget9 : public RenderTarget9 +{ + public: + SurfaceRenderTarget9(SwapChain9 *swapChain, bool depth); + ~SurfaceRenderTarget9() override; + + GLsizei getWidth() const override; + GLsizei getHeight() const override; + GLsizei getDepth() const override; + GLenum getInternalFormat() const override; + GLsizei getSamples() const override; + + IDirect3DBaseTexture9 *getTexture() const override; + size_t getTextureLevel() const override; + IDirect3DSurface9 *getSurface() const override; + + D3DFORMAT getD3DFormat() const override; + + private: + SwapChain9 *mSwapChain; + bool mDepth; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_RENDERTARGET9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp new file mode 100644 index 0000000000..d80997392d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp @@ -0,0 +1,3338 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Renderer9.cpp: Implements a back-end specific class for the D3D9 renderer. + +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" + +#include <EGL/eglext.h> +#include <sstream> + +#include "common/utilities.h" +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/FramebufferAttachment.h" +#include "libANGLE/Program.h" +#include "libANGLE/Renderbuffer.h" +#include "libANGLE/State.h" +#include "libANGLE/Surface.h" +#include "libANGLE/Texture.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/features.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/CompilerD3D.h" +#include "libANGLE/renderer/d3d/DeviceD3D.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" +#include "libANGLE/renderer/d3d/FramebufferD3D.h" +#include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/RenderbufferD3D.h" +#include "libANGLE/renderer/d3d/ShaderD3D.h" +#include "libANGLE/renderer/d3d/SurfaceD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d9/Blit9.h" +#include "libANGLE/renderer/d3d/d3d9/Buffer9.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/Fence9.h" +#include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/Image9.h" +#include "libANGLE/renderer/d3d/d3d9/IndexBuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/NativeWindow9.h" +#include "libANGLE/renderer/d3d/d3d9/Query9.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h" +#include "libANGLE/renderer/d3d/d3d9/SwapChain9.h" +#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h" +#include "libANGLE/renderer/d3d/d3d9/VertexArray9.h" +#include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" +#include "libANGLE/renderer/d3d/driver_utils_d3d.h" +#include "libANGLE/renderer/driver_utils.h" +#include "libANGLE/trace.h" + +#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL) +# define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3 +#endif + +// Enable ANGLE_SUPPORT_SHADER_MODEL_2 if you wish devices with only shader model 2. +// Such a device would not be conformant. +#ifndef ANGLE_SUPPORT_SHADER_MODEL_2 +# define ANGLE_SUPPORT_SHADER_MODEL_2 0 +#endif + +namespace rx +{ + +namespace +{ +enum +{ + MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256, + MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32, + MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224, + MAX_VARYING_VECTORS_SM2 = 8, + MAX_VARYING_VECTORS_SM3 = 10, + + MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4 +}; + +template <typename T> +static void DrawPoints(IDirect3DDevice9 *device, GLsizei count, const void *indices, int minIndex) +{ + for (int i = 0; i < count; i++) + { + unsigned int indexValue = + static_cast<unsigned int>(static_cast<const T *>(indices)[i]) - minIndex; + device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1); + } +} + +// A hard limit on buffer size. This works around a problem in the NVIDIA drivers where buffer sizes +// close to MAX_UINT would give undefined results. The limit of MAX_UINT/2 should be generous enough +// for almost any demanding application. +constexpr UINT kMaximumBufferSizeHardLimit = std::numeric_limits<UINT>::max() >> 1; +} // anonymous namespace + +Renderer9::Renderer9(egl::Display *display) : RendererD3D(display), mStateManager(this) +{ + mD3d9Module = nullptr; + + mD3d9 = nullptr; + mD3d9Ex = nullptr; + mDevice = nullptr; + mDeviceEx = nullptr; + mDeviceWindow = nullptr; + mBlit = nullptr; + + mAdapter = D3DADAPTER_DEFAULT; + + const egl::AttributeMap &attributes = display->getAttributeMap(); + EGLint requestedDeviceType = static_cast<EGLint>(attributes.get( + EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE)); + switch (requestedDeviceType) + { + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE: + mDeviceType = D3DDEVTYPE_HAL; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE: + mDeviceType = D3DDEVTYPE_REF; + break; + + case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE: + mDeviceType = D3DDEVTYPE_NULLREF; + break; + + default: + UNREACHABLE(); + } + + mMaskedClearSavedState = nullptr; + + mVertexDataManager = nullptr; + mIndexDataManager = nullptr; + mLineLoopIB = nullptr; + mCountingIB = nullptr; + + mMaxNullColorbufferLRU = 0; + for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++) + { + mNullRenderTargetCache[i].lruCount = 0; + mNullRenderTargetCache[i].width = 0; + mNullRenderTargetCache[i].height = 0; + mNullRenderTargetCache[i].renderTarget = nullptr; + } + + mAppliedVertexShader = nullptr; + mAppliedPixelShader = nullptr; + mAppliedProgramSerial = 0; + + gl::InitializeDebugAnnotations(&mAnnotator); +} + +void Renderer9::setGlobalDebugAnnotator() +{ + gl::InitializeDebugAnnotations(&mAnnotator); +} + +Renderer9::~Renderer9() +{ + if (mDevice) + { + // If the device is lost, reset it first to prevent leaving the driver in an unstable state + if (testDeviceLost()) + { + resetDevice(); + } + } + + release(); +} + +void Renderer9::release() +{ + gl::UninitializeDebugAnnotations(); + + mTranslatedAttribCache.clear(); + + releaseDeviceResources(); + + SafeRelease(mDevice); + SafeRelease(mDeviceEx); + SafeRelease(mD3d9); + SafeRelease(mD3d9Ex); + + mCompiler.release(); + + if (mDeviceWindow) + { + DestroyWindow(mDeviceWindow); + mDeviceWindow = nullptr; + } + + mD3d9Module = nullptr; +} + +egl::Error Renderer9::initialize() +{ + ANGLE_TRACE_EVENT0("gpu.angle", "GetModuleHandle_d3d9"); + mD3d9Module = ::LoadLibrary(TEXT("d3d9.dll")); + + if (mD3d9Module == nullptr) + { + return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "No D3D9 module found."; + } + + typedef HRESULT(WINAPI * Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex **); + Direct3DCreate9ExFunc Direct3DCreate9ExPtr = + reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex")); + + // Use Direct3D9Ex if available. Among other things, this version is less + // inclined to report a lost context, for example when the user switches + // desktop. Direct3D9Ex is available in Windows Vista and later if suitable drivers are + // available. + if (ANGLE_D3D9EX == ANGLE_ENABLED && Direct3DCreate9ExPtr && + SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &mD3d9Ex))) + { + ANGLE_TRACE_EVENT0("gpu.angle", "D3d9Ex_QueryInterface"); + ASSERT(mD3d9Ex); + mD3d9Ex->QueryInterface(__uuidof(IDirect3D9), reinterpret_cast<void **>(&mD3d9)); + ASSERT(mD3d9); + } + else + { + ANGLE_TRACE_EVENT0("gpu.angle", "Direct3DCreate9"); + mD3d9 = Direct3DCreate9(D3D_SDK_VERSION); + } + + if (!mD3d9) + { + return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "Could not create D3D9 device."; + } + + if (mDisplay->getNativeDisplayId() != nullptr) + { + // UNIMPLEMENTED(); // FIXME: Determine which adapter index the device context + // corresponds to + } + + HRESULT result; + + // Give up on getting device caps after about one second. + { + ANGLE_TRACE_EVENT0("gpu.angle", "GetDeviceCaps"); + for (int i = 0; i < 10; ++i) + { + result = mD3d9->GetDeviceCaps(mAdapter, mDeviceType, &mDeviceCaps); + if (SUCCEEDED(result)) + { + break; + } + else if (result == D3DERR_NOTAVAILABLE) + { + Sleep(100); // Give the driver some time to initialize/recover + } + else if (FAILED(result)) // D3DERR_OUTOFVIDEOMEMORY, E_OUTOFMEMORY, + // D3DERR_INVALIDDEVICE, or another error we can't recover + // from + { + return egl::EglNotInitialized(D3D9_INIT_OTHER_ERROR) + << "Failed to get device caps, " << gl::FmtHR(result); + } + } + } + +#if ANGLE_SUPPORT_SHADER_MODEL_2 + size_t minShaderModel = 2; +#else + size_t minShaderModel = 3; +#endif + + if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(minShaderModel, 0)) + { + return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_VERSION) + << "Renderer does not support PS " << minShaderModel << ".0, aborting!"; + } + + // When DirectX9 is running with an older DirectX8 driver, a StretchRect from a regular texture + // to a render target texture is not supported. This is required by + // Texture2D::ensureRenderTarget. + if ((mDeviceCaps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES) == 0) + { + return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_STRETCHRECT) + << "Renderer does not support StretctRect from textures."; + } + + { + ANGLE_TRACE_EVENT0("gpu.angle", "GetAdapterIdentifier"); + mD3d9->GetAdapterIdentifier(mAdapter, 0, &mAdapterIdentifier); + } + + static const TCHAR windowName[] = TEXT("AngleHiddenWindow"); + static const TCHAR className[] = TEXT("STATIC"); + + { + ANGLE_TRACE_EVENT0("gpu.angle", "CreateWindowEx"); + mDeviceWindow = + CreateWindowEx(WS_EX_NOACTIVATE, className, windowName, WS_DISABLED | WS_POPUP, 0, 0, 1, + 1, HWND_MESSAGE, nullptr, GetModuleHandle(nullptr), nullptr); + } + + D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters(); + DWORD behaviorFlags = + D3DCREATE_FPU_PRESERVE | D3DCREATE_NOWINDOWCHANGES | D3DCREATE_MULTITHREADED; + + { + ANGLE_TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice"); + result = mD3d9->CreateDevice( + mAdapter, mDeviceType, mDeviceWindow, + behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, + &presentParameters, &mDevice); + + if (FAILED(result)) + { + ERR() << "CreateDevice1 failed: (" << gl::FmtHR(result) << ")"; + } + } + if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST) + { + return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY) + << "CreateDevice failed: device lost or out of memory (" << gl::FmtHR(result) << ")"; + } + + if (FAILED(result)) + { + ANGLE_TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice2"); + result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, + behaviorFlags | D3DCREATE_SOFTWARE_VERTEXPROCESSING, + &presentParameters, &mDevice); + + if (FAILED(result)) + { + ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || + result == D3DERR_NOTAVAILABLE || result == D3DERR_DEVICELOST); + return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY) + << "CreateDevice2 failed: device lost, not available, or of out of memory (" + << gl::FmtHR(result) << ")"; + } + } + + if (mD3d9Ex) + { + ANGLE_TRACE_EVENT0("gpu.angle", "mDevice_QueryInterface"); + result = mDevice->QueryInterface(__uuidof(IDirect3DDevice9Ex), (void **)&mDeviceEx); + ASSERT(SUCCEEDED(result)); + } + + { + ANGLE_TRACE_EVENT0("gpu.angle", "ShaderCache initialize"); + mVertexShaderCache.initialize(mDevice); + mPixelShaderCache.initialize(mDevice); + } + + D3DDISPLAYMODE currentDisplayMode; + mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode); + + // Check vertex texture support + // Only Direct3D 10 ready devices support all the necessary vertex texture formats. + // We test this using D3D9 by checking support for the R16F format. + mVertexTextureSupport = mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0) && + SUCCEEDED(mD3d9->CheckDeviceFormat( + mAdapter, mDeviceType, currentDisplayMode.Format, + D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F)); + + ANGLE_TRY(initializeDevice()); + + return egl::NoError(); +} + +// do any one-time device initialization +// NOTE: this is also needed after a device lost/reset +// to reset the scene status and ensure the default states are reset. +egl::Error Renderer9::initializeDevice() +{ + // Permanent non-default states + mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE); + mDevice->SetRenderState(D3DRS_LASTPIXEL, FALSE); + + if (mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) + { + mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD &)mDeviceCaps.MaxPointSize); + } + else + { + mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000); // 1.0f + } + + const gl::Caps &rendererCaps = getNativeCaps(); + + mCurVertexSamplerStates.resize(rendererCaps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]); + mCurPixelSamplerStates.resize( + rendererCaps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]); + + mCurVertexTextures.resize(rendererCaps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]); + mCurPixelTextures.resize(rendererCaps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]); + + markAllStateDirty(); + + mSceneStarted = false; + + ASSERT(!mBlit); + mBlit = new Blit9(this); + + ASSERT(!mVertexDataManager && !mIndexDataManager); + mIndexDataManager = new IndexDataManager(this); + + mTranslatedAttribCache.resize(getNativeCaps().maxVertexAttributes); + + mStateManager.initialize(); + + return egl::NoError(); +} + +D3DPRESENT_PARAMETERS Renderer9::getDefaultPresentParameters() +{ + D3DPRESENT_PARAMETERS presentParameters = {}; + + // The default swap chain is never actually used. Surface will create a new swap chain with the + // proper parameters. + presentParameters.AutoDepthStencilFormat = D3DFMT_UNKNOWN; + presentParameters.BackBufferCount = 1; + presentParameters.BackBufferFormat = D3DFMT_UNKNOWN; + presentParameters.BackBufferWidth = 1; + presentParameters.BackBufferHeight = 1; + presentParameters.EnableAutoDepthStencil = FALSE; + presentParameters.Flags = 0; + presentParameters.hDeviceWindow = mDeviceWindow; + presentParameters.MultiSampleQuality = 0; + presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE; + presentParameters.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT; + presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD; + presentParameters.Windowed = TRUE; + + return presentParameters; +} + +egl::ConfigSet Renderer9::generateConfigs() +{ + static const GLenum colorBufferFormats[] = { + GL_BGR5_A1_ANGLEX, + GL_BGRA8_EXT, + GL_RGB565, + + }; + + static const GLenum depthStencilBufferFormats[] = { + GL_NONE, + GL_DEPTH_COMPONENT32_OES, + GL_DEPTH24_STENCIL8_OES, + GL_DEPTH_COMPONENT24_OES, + GL_DEPTH_COMPONENT16, + }; + + const gl::Caps &rendererCaps = getNativeCaps(); + const gl::TextureCapsMap &rendererTextureCaps = getNativeTextureCaps(); + + D3DDISPLAYMODE currentDisplayMode; + mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode); + + // Determine the min and max swap intervals + int minSwapInterval = 4; + int maxSwapInterval = 0; + + if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE) + { + minSwapInterval = std::min(minSwapInterval, 0); + maxSwapInterval = std::max(maxSwapInterval, 0); + } + if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE) + { + minSwapInterval = std::min(minSwapInterval, 1); + maxSwapInterval = std::max(maxSwapInterval, 1); + } + if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO) + { + minSwapInterval = std::min(minSwapInterval, 2); + maxSwapInterval = std::max(maxSwapInterval, 2); + } + if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE) + { + minSwapInterval = std::min(minSwapInterval, 3); + maxSwapInterval = std::max(maxSwapInterval, 3); + } + if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR) + { + minSwapInterval = std::min(minSwapInterval, 4); + maxSwapInterval = std::max(maxSwapInterval, 4); + } + + egl::ConfigSet configs; + for (size_t formatIndex = 0; formatIndex < ArraySize(colorBufferFormats); formatIndex++) + { + GLenum colorBufferInternalFormat = colorBufferFormats[formatIndex]; + const gl::TextureCaps &colorBufferFormatCaps = + rendererTextureCaps.get(colorBufferInternalFormat); + if (colorBufferFormatCaps.renderbuffer) + { + ASSERT(colorBufferFormatCaps.textureAttachment); + for (size_t depthStencilIndex = 0; + depthStencilIndex < ArraySize(depthStencilBufferFormats); depthStencilIndex++) + { + GLenum depthStencilBufferInternalFormat = + depthStencilBufferFormats[depthStencilIndex]; + const gl::TextureCaps &depthStencilBufferFormatCaps = + rendererTextureCaps.get(depthStencilBufferInternalFormat); + if (depthStencilBufferFormatCaps.renderbuffer || + depthStencilBufferInternalFormat == GL_NONE) + { + ASSERT(depthStencilBufferFormatCaps.textureAttachment || + depthStencilBufferInternalFormat == GL_NONE); + const gl::InternalFormat &colorBufferFormatInfo = + gl::GetSizedInternalFormatInfo(colorBufferInternalFormat); + const gl::InternalFormat &depthStencilBufferFormatInfo = + gl::GetSizedInternalFormatInfo(depthStencilBufferInternalFormat); + const d3d9::TextureFormat &d3d9ColorBufferFormatInfo = + d3d9::GetTextureFormatInfo(colorBufferInternalFormat); + + egl::Config config; + config.renderTargetFormat = colorBufferInternalFormat; + config.depthStencilFormat = depthStencilBufferInternalFormat; + config.bufferSize = colorBufferFormatInfo.pixelBytes * 8; + config.redSize = colorBufferFormatInfo.redBits; + config.greenSize = colorBufferFormatInfo.greenBits; + config.blueSize = colorBufferFormatInfo.blueBits; + config.luminanceSize = colorBufferFormatInfo.luminanceBits; + config.alphaSize = colorBufferFormatInfo.alphaBits; + config.alphaMaskSize = 0; + config.bindToTextureRGB = (colorBufferFormatInfo.format == GL_RGB); + config.bindToTextureRGBA = (colorBufferFormatInfo.format == GL_RGBA || + colorBufferFormatInfo.format == GL_BGRA_EXT); + config.colorBufferType = EGL_RGB_BUFFER; + // Mark as slow if blits to the back-buffer won't be straight forward + config.configCaveat = + (currentDisplayMode.Format == d3d9ColorBufferFormatInfo.renderFormat) + ? EGL_NONE + : EGL_SLOW_CONFIG; + config.configID = static_cast<EGLint>(configs.size() + 1); + config.conformant = EGL_OPENGL_ES2_BIT; + config.depthSize = depthStencilBufferFormatInfo.depthBits; + config.level = 0; + config.matchNativePixmap = EGL_NONE; + config.maxPBufferWidth = rendererCaps.max2DTextureSize; + config.maxPBufferHeight = rendererCaps.max2DTextureSize; + config.maxPBufferPixels = + rendererCaps.max2DTextureSize * rendererCaps.max2DTextureSize; + config.maxSwapInterval = maxSwapInterval; + config.minSwapInterval = minSwapInterval; + config.nativeRenderable = EGL_FALSE; + config.nativeVisualID = 0; + config.nativeVisualType = EGL_NONE; + config.renderableType = EGL_OPENGL_ES2_BIT; + config.sampleBuffers = 0; // FIXME: enumerate multi-sampling + config.samples = 0; + config.stencilSize = depthStencilBufferFormatInfo.stencilBits; + config.surfaceType = + EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT; + config.transparentType = EGL_NONE; + config.transparentRedValue = 0; + config.transparentGreenValue = 0; + config.transparentBlueValue = 0; + config.colorComponentType = gl_egl::GLComponentTypeToEGLColorComponentType( + colorBufferFormatInfo.componentType); + + configs.add(config); + } + } + } + } + + ASSERT(configs.size() > 0); + return configs; +} + +void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const +{ + outExtensions->createContextRobustness = true; + + if (getShareHandleSupport()) + { + outExtensions->d3dShareHandleClientBuffer = true; + outExtensions->surfaceD3DTexture2DShareHandle = true; + } + outExtensions->d3dTextureClientBuffer = true; + + outExtensions->querySurfacePointer = true; + outExtensions->windowFixedSize = true; + outExtensions->postSubBuffer = true; + + outExtensions->image = true; + outExtensions->imageBase = true; + outExtensions->glTexture2DImage = true; + outExtensions->glRenderbufferImage = true; + + outExtensions->noConfigContext = true; + + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; + + // D3D9 can be used without an output surface + outExtensions->surfacelessContext = true; + + outExtensions->robustResourceInitializationANGLE = true; +} + +void Renderer9::startScene() +{ + if (!mSceneStarted) + { + long result = mDevice->BeginScene(); + if (SUCCEEDED(result)) + { + // This is defensive checking against the device being + // lost at unexpected times. + mSceneStarted = true; + } + } +} + +void Renderer9::endScene() +{ + if (mSceneStarted) + { + // EndScene can fail if the device was lost, for example due + // to a TDR during a draw call. + mDevice->EndScene(); + mSceneStarted = false; + } +} + +angle::Result Renderer9::flush(const gl::Context *context) +{ + IDirect3DQuery9 *query = nullptr; + ANGLE_TRY(allocateEventQuery(context, &query)); + + Context9 *context9 = GetImplAs<Context9>(context); + + HRESULT result = query->Issue(D3DISSUE_END); + ANGLE_TRY_HR(context9, result, "Failed to issue event query"); + + // Grab the query data once + result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH); + freeEventQuery(query); + ANGLE_TRY_HR(context9, result, "Failed to get event query data"); + + return angle::Result::Continue; +} + +angle::Result Renderer9::finish(const gl::Context *context) +{ + IDirect3DQuery9 *query = nullptr; + ANGLE_TRY(allocateEventQuery(context, &query)); + + Context9 *context9 = GetImplAs<Context9>(context); + + HRESULT result = query->Issue(D3DISSUE_END); + ANGLE_TRY_HR(context9, result, "Failed to issue event query"); + + // Grab the query data once + result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH); + if (FAILED(result)) + { + freeEventQuery(query); + } + ANGLE_TRY_HR(context9, result, "Failed to get event query data"); + + // Loop until the query completes + unsigned int attempt = 0; + while (result == S_FALSE) + { + // Keep polling, but allow other threads to do something useful first + ScheduleYield(); + + result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH); + attempt++; + + if (result == S_FALSE) + { + // explicitly check for device loss + // some drivers seem to return S_FALSE even if the device is lost + // instead of D3DERR_DEVICELOST like they should + bool checkDeviceLost = (attempt % kPollingD3DDeviceLostCheckFrequency) == 0; + if (checkDeviceLost && testDeviceLost()) + { + result = D3DERR_DEVICELOST; + } + } + + if (FAILED(result)) + { + freeEventQuery(query); + } + ANGLE_TRY_HR(context9, result, "Failed to get event query data"); + } + + freeEventQuery(query); + + return angle::Result::Continue; +} + +bool Renderer9::isValidNativeWindow(EGLNativeWindowType window) const +{ + return NativeWindow9::IsValidNativeWindow(window); +} + +NativeWindowD3D *Renderer9::createNativeWindow(EGLNativeWindowType window, + const egl::Config *, + const egl::AttributeMap &) const +{ + return new NativeWindow9(window); +} + +SwapChainD3D *Renderer9::createSwapChain(NativeWindowD3D *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) +{ + return new SwapChain9(this, GetAs<NativeWindow9>(nativeWindow), shareHandle, d3dTexture, + backBufferFormat, depthBufferFormat, orientation); +} + +egl::Error Renderer9::getD3DTextureInfo(const egl::Config *configuration, + IUnknown *d3dTexture, + const egl::AttributeMap &attribs, + EGLint *width, + EGLint *height, + GLsizei *samples, + gl::Format *glFormat, + const angle::Format **angleFormat, + UINT *arraySlice) const +{ + IDirect3DTexture9 *texture = nullptr; + if (FAILED(d3dTexture->QueryInterface(&texture))) + { + return egl::EglBadParameter() << "Client buffer is not a IDirect3DTexture9"; + } + + IDirect3DDevice9 *textureDevice = nullptr; + texture->GetDevice(&textureDevice); + if (textureDevice != mDevice) + { + SafeRelease(texture); + return egl::EglBadParameter() << "Texture's device does not match."; + } + SafeRelease(textureDevice); + + D3DSURFACE_DESC desc; + texture->GetLevelDesc(0, &desc); + SafeRelease(texture); + + if (width) + { + *width = static_cast<EGLint>(desc.Width); + } + if (height) + { + *height = static_cast<EGLint>(desc.Height); + } + + // GetSamplesCount() returns 0 when multisampling isn't used. + GLsizei sampleCount = d3d9_gl::GetSamplesCount(desc.MultiSampleType); + if ((configuration && configuration->samples > 1) || sampleCount != 0) + { + return egl::EglBadParameter() << "Multisampling not supported for client buffer texture"; + } + if (samples) + { + *samples = static_cast<EGLint>(sampleCount); + } + + // From table egl.restrictions in EGL_ANGLE_d3d_texture_client_buffer. + switch (desc.Format) + { + case D3DFMT_R8G8B8: + case D3DFMT_A8R8G8B8: + case D3DFMT_A16B16G16R16F: + case D3DFMT_A32B32G32R32F: + break; + + default: + return egl::EglBadParameter() + << "Unknown client buffer texture format: " << desc.Format; + } + + const auto &d3dFormatInfo = d3d9::GetD3DFormatInfo(desc.Format); + ASSERT(d3dFormatInfo.info().id != angle::FormatID::NONE); + + if (glFormat) + { + *glFormat = gl::Format(d3dFormatInfo.info().glInternalFormat); + } + + if (angleFormat) + { + + *angleFormat = &d3dFormatInfo.info(); + } + + if (arraySlice) + { + *arraySlice = 0; + } + + return egl::NoError(); +} + +egl::Error Renderer9::validateShareHandle(const egl::Config *config, + HANDLE shareHandle, + const egl::AttributeMap &attribs) const +{ + if (shareHandle == nullptr) + { + return egl::EglBadParameter() << "NULL share handle."; + } + + EGLint width = attribs.getAsInt(EGL_WIDTH, 0); + EGLint height = attribs.getAsInt(EGL_HEIGHT, 0); + ASSERT(width != 0 && height != 0); + + const d3d9::TextureFormat &backBufferd3dFormatInfo = + d3d9::GetTextureFormatInfo(config->renderTargetFormat); + + IDirect3DTexture9 *texture = nullptr; + HRESULT result = mDevice->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, + backBufferd3dFormatInfo.texFormat, D3DPOOL_DEFAULT, + &texture, &shareHandle); + if (FAILED(result)) + { + return egl::EglBadParameter() << "Failed to open share handle, " << gl::FmtHR(result); + } + + DWORD levelCount = texture->GetLevelCount(); + + D3DSURFACE_DESC desc; + texture->GetLevelDesc(0, &desc); + SafeRelease(texture); + + if (levelCount != 1 || desc.Width != static_cast<UINT>(width) || + desc.Height != static_cast<UINT>(height) || + desc.Format != backBufferd3dFormatInfo.texFormat) + { + return egl::EglBadParameter() << "Invalid texture parameters in share handle texture."; + } + + return egl::NoError(); +} + +ContextImpl *Renderer9::createContext(const gl::State &state, gl::ErrorSet *errorSet) +{ + return new Context9(state, errorSet, this); +} + +void *Renderer9::getD3DDevice() +{ + return mDevice; +} + +angle::Result Renderer9::allocateEventQuery(const gl::Context *context, IDirect3DQuery9 **outQuery) +{ + if (mEventQueryPool.empty()) + { + HRESULT result = mDevice->CreateQuery(D3DQUERYTYPE_EVENT, outQuery); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to allocate event query"); + } + else + { + *outQuery = mEventQueryPool.back(); + mEventQueryPool.pop_back(); + } + + return angle::Result::Continue; +} + +void Renderer9::freeEventQuery(IDirect3DQuery9 *query) +{ + if (mEventQueryPool.size() > 1000) + { + SafeRelease(query); + } + else + { + mEventQueryPool.push_back(query); + } +} + +angle::Result Renderer9::createVertexShader(d3d::Context *context, + const DWORD *function, + size_t length, + IDirect3DVertexShader9 **outShader) +{ + return mVertexShaderCache.create(context, function, length, outShader); +} + +angle::Result Renderer9::createPixelShader(d3d::Context *context, + const DWORD *function, + size_t length, + IDirect3DPixelShader9 **outShader) +{ + return mPixelShaderCache.create(context, function, length, outShader); +} + +HRESULT Renderer9::createVertexBuffer(UINT Length, + DWORD Usage, + IDirect3DVertexBuffer9 **ppVertexBuffer) +{ + // Force buffers to be limited to a fixed max size. + if (Length > kMaximumBufferSizeHardLimit) + { + return E_OUTOFMEMORY; + } + + D3DPOOL Pool = getBufferPool(Usage); + return mDevice->CreateVertexBuffer(Length, Usage, 0, Pool, ppVertexBuffer, nullptr); +} + +VertexBuffer *Renderer9::createVertexBuffer() +{ + return new VertexBuffer9(this); +} + +HRESULT Renderer9::createIndexBuffer(UINT Length, + DWORD Usage, + D3DFORMAT Format, + IDirect3DIndexBuffer9 **ppIndexBuffer) +{ + // Force buffers to be limited to a fixed max size. + if (Length > kMaximumBufferSizeHardLimit) + { + return E_OUTOFMEMORY; + } + + D3DPOOL Pool = getBufferPool(Usage); + return mDevice->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, nullptr); +} + +IndexBuffer *Renderer9::createIndexBuffer() +{ + return new IndexBuffer9(this); +} + +StreamProducerImpl *Renderer9::createStreamProducerD3DTexture( + egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) +{ + // Streams are not supported under D3D9 + UNREACHABLE(); + return nullptr; +} + +bool Renderer9::supportsFastCopyBufferToTexture(GLenum internalFormat) const +{ + // Pixel buffer objects are not supported in D3D9, since D3D9 is ES2-only and PBOs are ES3. + return false; +} + +angle::Result Renderer9::fastCopyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) +{ + // Pixel buffer objects are not supported in D3D9, since D3D9 is ES2-only and PBOs are ES3. + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Renderer9::setSamplerState(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &samplerState) +{ + CurSamplerState &appliedSampler = (type == gl::ShaderType::Fragment) + ? mCurPixelSamplerStates[index] + : mCurVertexSamplerStates[index]; + + // Make sure to add the level offset for our tiny compressed texture workaround + TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture); + + TextureStorage *storage = nullptr; + ANGLE_TRY(textureD3D->getNativeTexture(context, &storage)); + + // Storage should exist, texture should be complete + ASSERT(storage); + + DWORD baseLevel = texture->getBaseLevel() + storage->getTopLevel(); + + if (appliedSampler.forceSet || appliedSampler.baseLevel != baseLevel || + memcmp(&samplerState, &appliedSampler, sizeof(gl::SamplerState)) != 0) + { + int d3dSamplerOffset = (type == gl::ShaderType::Fragment) ? 0 : D3DVERTEXTEXTURESAMPLER0; + int d3dSampler = index + d3dSamplerOffset; + + mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU, + gl_d3d9::ConvertTextureWrap(samplerState.getWrapS())); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV, + gl_d3d9::ConvertTextureWrap(samplerState.getWrapT())); + + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAGFILTER, + gl_d3d9::ConvertMagFilter(samplerState.getMagFilter(), + samplerState.getMaxAnisotropy())); + + D3DTEXTUREFILTERTYPE d3dMinFilter, d3dMipFilter; + float lodBias; + gl_d3d9::ConvertMinFilter(samplerState.getMinFilter(), &d3dMinFilter, &d3dMipFilter, + &lodBias, samplerState.getMaxAnisotropy(), baseLevel); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MINFILTER, d3dMinFilter); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPFILTER, d3dMipFilter); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXMIPLEVEL, baseLevel); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPMAPLODBIAS, static_cast<DWORD>(lodBias)); + if (getNativeExtensions().textureFilterAnisotropicEXT) + { + DWORD maxAnisotropy = std::min(mDeviceCaps.MaxAnisotropy, + static_cast<DWORD>(samplerState.getMaxAnisotropy())); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXANISOTROPY, maxAnisotropy); + } + + const bool isSrgb = gl::GetSizedInternalFormatInfo(textureD3D->getBaseLevelInternalFormat()) + .colorEncoding == GL_SRGB; + mDevice->SetSamplerState(d3dSampler, D3DSAMP_SRGBTEXTURE, isSrgb); + + ASSERT(texture->getBorderColor().type == angle::ColorGeneric::Type::Float); + mDevice->SetSamplerState(d3dSampler, D3DSAMP_BORDERCOLOR, + gl_d3d9::ConvertColor(texture->getBorderColor().colorF)); + } + + appliedSampler.forceSet = false; + appliedSampler.samplerState = samplerState; + appliedSampler.baseLevel = baseLevel; + + return angle::Result::Continue; +} + +angle::Result Renderer9::setTexture(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture) +{ + int d3dSamplerOffset = (type == gl::ShaderType::Fragment) ? 0 : D3DVERTEXTEXTURESAMPLER0; + int d3dSampler = index + d3dSamplerOffset; + IDirect3DBaseTexture9 *d3dTexture = nullptr; + bool forceSetTexture = false; + + std::vector<uintptr_t> &appliedTextures = + (type == gl::ShaderType::Fragment) ? mCurPixelTextures : mCurVertexTextures; + + if (texture) + { + TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture); + + TextureStorage *texStorage = nullptr; + ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage)); + + // Texture should be complete and have a storage + ASSERT(texStorage); + + TextureStorage9 *storage9 = GetAs<TextureStorage9>(texStorage); + ANGLE_TRY(storage9->getBaseTexture(context, &d3dTexture)); + + // If we get NULL back from getBaseTexture here, something went wrong + // in the texture class and we're unexpectedly missing the d3d texture + ASSERT(d3dTexture != nullptr); + + forceSetTexture = textureImpl->hasDirtyImages(); + textureImpl->resetDirty(); + } + + if (forceSetTexture || appliedTextures[index] != reinterpret_cast<uintptr_t>(d3dTexture)) + { + mDevice->SetTexture(d3dSampler, d3dTexture); + } + + appliedTextures[index] = reinterpret_cast<uintptr_t>(d3dTexture); + + return angle::Result::Continue; +} + +angle::Result Renderer9::updateState(const gl::Context *context, gl::PrimitiveMode drawMode) +{ + const auto &glState = context->getState(); + + // Applies the render target surface, depth stencil surface, viewport rectangle and + // scissor rectangle to the renderer + gl::Framebuffer *framebuffer = glState.getDrawFramebuffer(); + ASSERT(framebuffer && !framebuffer->hasAnyDirtyBit()); + + Framebuffer9 *framebuffer9 = GetImplAs<Framebuffer9>(framebuffer); + + ANGLE_TRY(applyRenderTarget(context, framebuffer9->getCachedColorRenderTargets()[0], + framebuffer9->getCachedDepthStencilRenderTarget())); + + // Setting viewport state + setViewport(glState.getViewport(), glState.getNearPlane(), glState.getFarPlane(), drawMode, + glState.getRasterizerState().frontFace, false); + + // Setting scissors state + setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled()); + + // Setting blend, depth stencil, and rasterizer states + // Since framebuffer->getSamples will return the original samples which may be different with + // the sample counts that we set in render target view, here we use renderTarget->getSamples to + // get the actual samples. + GLsizei samples = 0; + const gl::FramebufferAttachment *firstColorAttachment = framebuffer->getFirstColorAttachment(); + if (firstColorAttachment) + { + ASSERT(firstColorAttachment->isAttached()); + RenderTarget9 *renderTarget = nullptr; + ANGLE_TRY(firstColorAttachment->getRenderTarget(context, firstColorAttachment->getSamples(), + &renderTarget)); + samples = renderTarget->getSamples(); + + mDevice->SetRenderState(D3DRS_SRGBWRITEENABLE, + renderTarget->getInternalFormat() == GL_SRGB8_ALPHA8); + } + gl::RasterizerState rasterizer = glState.getRasterizerState(); + rasterizer.pointDrawMode = (drawMode == gl::PrimitiveMode::Points); + rasterizer.multiSample = (samples != 0); + + ANGLE_TRY(setBlendDepthRasterStates(context, drawMode)); + + mStateManager.resetDirtyBits(); + + return angle::Result::Continue; +} + +void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled) +{ + mStateManager.setScissorState(scissor, enabled); +} + +angle::Result Renderer9::setBlendDepthRasterStates(const gl::Context *context, + gl::PrimitiveMode drawMode) +{ + const auto &glState = context->getState(); + gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer(); + ASSERT(!drawFramebuffer->hasAnyDirtyBit()); + // Since framebuffer->getSamples will return the original samples which may be different with + // the sample counts that we set in render target view, here we use renderTarget->getSamples to + // get the actual samples. + GLsizei samples = 0; + const gl::FramebufferAttachment *firstColorAttachment = + drawFramebuffer->getFirstColorAttachment(); + if (firstColorAttachment) + { + ASSERT(firstColorAttachment->isAttached()); + RenderTarget9 *renderTarget = nullptr; + ANGLE_TRY(firstColorAttachment->getRenderTarget(context, firstColorAttachment->getSamples(), + &renderTarget)); + samples = renderTarget->getSamples(); + } + gl::RasterizerState rasterizer = glState.getRasterizerState(); + rasterizer.pointDrawMode = (drawMode == gl::PrimitiveMode::Points); + rasterizer.multiSample = (samples != 0); + + unsigned int mask = GetBlendSampleMask(glState, samples); + mStateManager.setBlendDepthRasterStates(glState, mask); + return angle::Result::Continue; +} + +void Renderer9::setViewport(const gl::Rectangle &viewport, + float zNear, + float zFar, + gl::PrimitiveMode drawMode, + GLenum frontFace, + bool ignoreViewport) +{ + mStateManager.setViewportState(viewport, zNear, zFar, drawMode, frontFace, ignoreViewport); +} + +bool Renderer9::applyPrimitiveType(gl::PrimitiveMode mode, GLsizei count, bool usesPointSize) +{ + switch (mode) + { + case gl::PrimitiveMode::Points: + mPrimitiveType = D3DPT_POINTLIST; + mPrimitiveCount = count; + break; + case gl::PrimitiveMode::Lines: + mPrimitiveType = D3DPT_LINELIST; + mPrimitiveCount = count / 2; + break; + case gl::PrimitiveMode::LineLoop: + mPrimitiveType = D3DPT_LINESTRIP; + mPrimitiveCount = + count - 1; // D3D doesn't support line loops, so we draw the last line separately + break; + case gl::PrimitiveMode::LineStrip: + mPrimitiveType = D3DPT_LINESTRIP; + mPrimitiveCount = count - 1; + break; + case gl::PrimitiveMode::Triangles: + mPrimitiveType = D3DPT_TRIANGLELIST; + mPrimitiveCount = count / 3; + break; + case gl::PrimitiveMode::TriangleStrip: + mPrimitiveType = D3DPT_TRIANGLESTRIP; + mPrimitiveCount = count - 2; + break; + case gl::PrimitiveMode::TriangleFan: + mPrimitiveType = D3DPT_TRIANGLEFAN; + mPrimitiveCount = count - 2; + break; + default: + UNREACHABLE(); + return false; + } + + return mPrimitiveCount > 0; +} + +angle::Result Renderer9::getNullColorRenderTarget(const gl::Context *context, + const RenderTarget9 *depthRenderTarget, + const RenderTarget9 **outColorRenderTarget) +{ + ASSERT(depthRenderTarget); + + const gl::Extents &size = depthRenderTarget->getExtents(); + + // search cached nullcolorbuffers + for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++) + { + if (mNullRenderTargetCache[i].renderTarget != nullptr && + mNullRenderTargetCache[i].width == size.width && + mNullRenderTargetCache[i].height == size.height) + { + mNullRenderTargetCache[i].lruCount = ++mMaxNullColorbufferLRU; + *outColorRenderTarget = mNullRenderTargetCache[i].renderTarget; + return angle::Result::Continue; + } + } + + RenderTargetD3D *nullRenderTarget = nullptr; + ANGLE_TRY(createRenderTarget(context, size.width, size.height, GL_NONE, 0, &nullRenderTarget)); + + // add nullbuffer to the cache + NullRenderTargetCacheEntry *oldest = &mNullRenderTargetCache[0]; + for (int i = 1; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++) + { + if (mNullRenderTargetCache[i].lruCount < oldest->lruCount) + { + oldest = &mNullRenderTargetCache[i]; + } + } + + SafeDelete(oldest->renderTarget); + oldest->renderTarget = GetAs<RenderTarget9>(nullRenderTarget); + oldest->lruCount = ++mMaxNullColorbufferLRU; + oldest->width = size.width; + oldest->height = size.height; + + *outColorRenderTarget = oldest->renderTarget; + return angle::Result::Continue; +} + +angle::Result Renderer9::applyRenderTarget(const gl::Context *context, + const RenderTarget9 *colorRenderTargetIn, + const RenderTarget9 *depthStencilRenderTarget) +{ + // if there is no color attachment we must synthesize a NULL colorattachment + // to keep the D3D runtime happy. This should only be possible if depth texturing. + const RenderTarget9 *colorRenderTarget = colorRenderTargetIn; + if (colorRenderTarget == nullptr) + { + ANGLE_TRY(getNullColorRenderTarget(context, depthStencilRenderTarget, &colorRenderTarget)); + } + ASSERT(colorRenderTarget != nullptr); + + size_t renderTargetWidth = 0; + size_t renderTargetHeight = 0; + + bool renderTargetChanged = false; + unsigned int renderTargetSerial = colorRenderTarget->getSerial(); + if (renderTargetSerial != mAppliedRenderTargetSerial) + { + // Apply the render target on the device + IDirect3DSurface9 *renderTargetSurface = colorRenderTarget->getSurface(); + ASSERT(renderTargetSurface); + + mDevice->SetRenderTarget(0, renderTargetSurface); + SafeRelease(renderTargetSurface); + + renderTargetWidth = colorRenderTarget->getWidth(); + renderTargetHeight = colorRenderTarget->getHeight(); + + mAppliedRenderTargetSerial = renderTargetSerial; + renderTargetChanged = true; + } + + unsigned int depthStencilSerial = 0; + if (depthStencilRenderTarget != nullptr) + { + depthStencilSerial = depthStencilRenderTarget->getSerial(); + } + + if (depthStencilSerial != mAppliedDepthStencilSerial || !mDepthStencilInitialized) + { + unsigned int depthSize = 0; + unsigned int stencilSize = 0; + + // Apply the depth stencil on the device + if (depthStencilRenderTarget) + { + IDirect3DSurface9 *depthStencilSurface = depthStencilRenderTarget->getSurface(); + ASSERT(depthStencilSurface); + + mDevice->SetDepthStencilSurface(depthStencilSurface); + SafeRelease(depthStencilSurface); + + const gl::InternalFormat &format = + gl::GetSizedInternalFormatInfo(depthStencilRenderTarget->getInternalFormat()); + + depthSize = format.depthBits; + stencilSize = format.stencilBits; + } + else + { + mDevice->SetDepthStencilSurface(nullptr); + } + + mStateManager.updateDepthSizeIfChanged(mDepthStencilInitialized, depthSize); + mStateManager.updateStencilSizeIfChanged(mDepthStencilInitialized, stencilSize); + + mAppliedDepthStencilSerial = depthStencilSerial; + mDepthStencilInitialized = true; + } + + if (renderTargetChanged || !mRenderTargetDescInitialized) + { + mStateManager.forceSetBlendState(); + mStateManager.forceSetScissorState(); + mStateManager.setRenderTargetBounds(renderTargetWidth, renderTargetHeight); + mRenderTargetDescInitialized = true; + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::applyVertexBuffer(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instances, + TranslatedIndexData * /*indexInfo*/) +{ + const gl::State &state = context->getState(); + ANGLE_TRY(mVertexDataManager->prepareVertexData(context, first, count, &mTranslatedAttribCache, + instances)); + + return mVertexDeclarationCache.applyDeclaration(context, mDevice, mTranslatedAttribCache, + state.getProgram(), first, instances, + &mRepeatDraw); +} + +// Applies the indices and element array bindings to the Direct3D 9 device +angle::Result Renderer9::applyIndexBuffer(const gl::Context *context, + const void *indices, + GLsizei count, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + TranslatedIndexData *indexInfo) +{ + gl::VertexArray *vao = context->getState().getVertexArray(); + gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer(); + + gl::DrawElementsType dstType = gl::DrawElementsType::InvalidEnum; + ANGLE_TRY(GetIndexTranslationDestType(context, count, type, indices, false, &dstType)); + + ANGLE_TRY(mIndexDataManager->prepareIndexData(context, type, dstType, count, elementArrayBuffer, + indices, indexInfo)); + + // Directly binding the storage buffer is not supported for d3d9 + ASSERT(indexInfo->storage == nullptr); + + if (indexInfo->serial != mAppliedIBSerial) + { + IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(indexInfo->indexBuffer); + + mDevice->SetIndices(indexBuffer->getBuffer()); + mAppliedIBSerial = indexInfo->serial; + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::drawArraysImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLint startVertex, + GLsizei count, + GLsizei instances) +{ + ASSERT(!context->getState().isTransformFeedbackActiveUnpaused()); + + startScene(); + + if (mode == gl::PrimitiveMode::LineLoop) + { + return drawLineLoop(context, count, gl::DrawElementsType::InvalidEnum, nullptr, 0, nullptr); + } + + if (instances > 0) + { + StaticIndexBufferInterface *countingIB = nullptr; + ANGLE_TRY(getCountingIB(context, count, &countingIB)); + + if (mAppliedIBSerial != countingIB->getSerial()) + { + IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(countingIB->getIndexBuffer()); + + mDevice->SetIndices(indexBuffer->getBuffer()); + mAppliedIBSerial = countingIB->getSerial(); + } + + for (int i = 0; i < mRepeatDraw; i++) + { + mDevice->DrawIndexedPrimitive(mPrimitiveType, 0, 0, count, 0, mPrimitiveCount); + } + + return angle::Result::Continue; + } + + // Regular case + mDevice->DrawPrimitive(mPrimitiveType, 0, mPrimitiveCount); + return angle::Result::Continue; +} + +angle::Result Renderer9::drawElementsImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) +{ + TranslatedIndexData indexInfo; + + ANGLE_TRY(applyIndexBuffer(context, indices, count, mode, type, &indexInfo)); + + gl::IndexRange indexRange; + ANGLE_TRY(context->getState().getVertexArray()->getIndexRange(context, type, count, indices, + &indexRange)); + + size_t vertexCount = indexRange.vertexCount(); + ANGLE_TRY(applyVertexBuffer(context, mode, static_cast<GLsizei>(indexRange.start), + static_cast<GLsizei>(vertexCount), instances, &indexInfo)); + + startScene(); + + int minIndex = static_cast<int>(indexRange.start); + + gl::VertexArray *vao = context->getState().getVertexArray(); + gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer(); + + if (mode == gl::PrimitiveMode::Points) + { + return drawIndexedPoints(context, count, type, indices, minIndex, elementArrayBuffer); + } + + if (mode == gl::PrimitiveMode::LineLoop) + { + return drawLineLoop(context, count, type, indices, minIndex, elementArrayBuffer); + } + + for (int i = 0; i < mRepeatDraw; i++) + { + mDevice->DrawIndexedPrimitive(mPrimitiveType, -minIndex, minIndex, + static_cast<UINT>(vertexCount), indexInfo.startIndex, + mPrimitiveCount); + } + return angle::Result::Continue; +} + +angle::Result Renderer9::drawLineLoop(const gl::Context *context, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + int minIndex, + gl::Buffer *elementArrayBuffer) +{ + // Get the raw indices for an indexed draw + if (type != gl::DrawElementsType::InvalidEnum && elementArrayBuffer) + { + BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer); + intptr_t offset = reinterpret_cast<intptr_t>(indices); + const uint8_t *bufferData = nullptr; + ANGLE_TRY(storage->getData(context, &bufferData)); + indices = bufferData + offset; + } + + unsigned int startIndex = 0; + Context9 *context9 = GetImplAs<Context9>(context); + + if (getNativeExtensions().elementIndexUintOES) + { + if (!mLineLoopIB) + { + mLineLoopIB = new StreamingIndexBufferInterface(this); + ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE, + gl::DrawElementsType::UnsignedInt)); + } + + // Checked by Renderer9::applyPrimitiveType + ASSERT(count >= 0); + + ANGLE_CHECK(context9, + static_cast<unsigned int>(count) + 1 <= + (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)), + "Failed to create a 32-bit looping index buffer for " + "GL_LINE_LOOP, too many indices required.", + GL_OUT_OF_MEMORY); + + const unsigned int spaceNeeded = + (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int); + ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, spaceNeeded, + gl::DrawElementsType::UnsignedInt)); + + void *mappedMemory = nullptr; + unsigned int offset = 0; + ANGLE_TRY(mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset)); + + startIndex = static_cast<unsigned int>(offset) / 4; + unsigned int *data = static_cast<unsigned int *>(mappedMemory); + + switch (type) + { + case gl::DrawElementsType::InvalidEnum: // Non-indexed draw + for (int i = 0; i < count; i++) + { + data[i] = i; + } + data[count] = 0; + break; + case gl::DrawElementsType::UnsignedByte: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<const GLubyte *>(indices)[i]; + } + data[count] = static_cast<const GLubyte *>(indices)[0]; + break; + case gl::DrawElementsType::UnsignedShort: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<const GLushort *>(indices)[i]; + } + data[count] = static_cast<const GLushort *>(indices)[0]; + break; + case gl::DrawElementsType::UnsignedInt: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<const GLuint *>(indices)[i]; + } + data[count] = static_cast<const GLuint *>(indices)[0]; + break; + default: + UNREACHABLE(); + } + + ANGLE_TRY(mLineLoopIB->unmapBuffer(context)); + } + else + { + if (!mLineLoopIB) + { + mLineLoopIB = new StreamingIndexBufferInterface(this); + ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE, + gl::DrawElementsType::UnsignedShort)); + } + + // Checked by Renderer9::applyPrimitiveType + ASSERT(count >= 0); + + ANGLE_CHECK(context9, + static_cast<unsigned int>(count) + 1 <= + (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)), + "Failed to create a 16-bit looping index buffer for " + "GL_LINE_LOOP, too many indices required.", + GL_OUT_OF_MEMORY); + + const unsigned int spaceNeeded = + (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short); + ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, spaceNeeded, + gl::DrawElementsType::UnsignedShort)); + + void *mappedMemory = nullptr; + unsigned int offset; + ANGLE_TRY(mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset)); + + startIndex = static_cast<unsigned int>(offset) / 2; + unsigned short *data = static_cast<unsigned short *>(mappedMemory); + + switch (type) + { + case gl::DrawElementsType::InvalidEnum: // Non-indexed draw + for (int i = 0; i < count; i++) + { + data[i] = static_cast<unsigned short>(i); + } + data[count] = 0; + break; + case gl::DrawElementsType::UnsignedByte: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<const GLubyte *>(indices)[i]; + } + data[count] = static_cast<const GLubyte *>(indices)[0]; + break; + case gl::DrawElementsType::UnsignedShort: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<const GLushort *>(indices)[i]; + } + data[count] = static_cast<const GLushort *>(indices)[0]; + break; + case gl::DrawElementsType::UnsignedInt: + for (int i = 0; i < count; i++) + { + data[i] = static_cast<unsigned short>(static_cast<const GLuint *>(indices)[i]); + } + data[count] = static_cast<unsigned short>(static_cast<const GLuint *>(indices)[0]); + break; + default: + UNREACHABLE(); + } + + ANGLE_TRY(mLineLoopIB->unmapBuffer(context)); + } + + if (mAppliedIBSerial != mLineLoopIB->getSerial()) + { + IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(mLineLoopIB->getIndexBuffer()); + + mDevice->SetIndices(indexBuffer->getBuffer()); + mAppliedIBSerial = mLineLoopIB->getSerial(); + } + + mDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, -minIndex, minIndex, count, startIndex, count); + + return angle::Result::Continue; +} + +angle::Result Renderer9::drawIndexedPoints(const gl::Context *context, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + int minIndex, + gl::Buffer *elementArrayBuffer) +{ + // Drawing index point lists is unsupported in d3d9, fall back to a regular DrawPrimitive call + // for each individual point. This call is not expected to happen often. + + if (elementArrayBuffer) + { + BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer); + intptr_t offset = reinterpret_cast<intptr_t>(indices); + + const uint8_t *bufferData = nullptr; + ANGLE_TRY(storage->getData(context, &bufferData)); + indices = bufferData + offset; + } + + switch (type) + { + case gl::DrawElementsType::UnsignedByte: + DrawPoints<GLubyte>(mDevice, count, indices, minIndex); + return angle::Result::Continue; + case gl::DrawElementsType::UnsignedShort: + DrawPoints<GLushort>(mDevice, count, indices, minIndex); + return angle::Result::Continue; + case gl::DrawElementsType::UnsignedInt: + DrawPoints<GLuint>(mDevice, count, indices, minIndex); + return angle::Result::Continue; + default: + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + } +} + +angle::Result Renderer9::getCountingIB(const gl::Context *context, + size_t count, + StaticIndexBufferInterface **outIB) +{ + // Update the counting index buffer if it is not large enough or has not been created yet. + if (count <= 65536) // 16-bit indices + { + const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned short); + + if (!mCountingIB || mCountingIB->getBufferSize() < spaceNeeded) + { + SafeDelete(mCountingIB); + mCountingIB = new StaticIndexBufferInterface(this); + ANGLE_TRY(mCountingIB->reserveBufferSpace(context, spaceNeeded, + gl::DrawElementsType::UnsignedShort)); + + void *mappedMemory = nullptr; + ANGLE_TRY(mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr)); + + unsigned short *data = static_cast<unsigned short *>(mappedMemory); + for (size_t i = 0; i < count; i++) + { + data[i] = static_cast<unsigned short>(i); + } + + ANGLE_TRY(mCountingIB->unmapBuffer(context)); + } + } + else if (getNativeExtensions().elementIndexUintOES) + { + const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned int); + + if (!mCountingIB || mCountingIB->getBufferSize() < spaceNeeded) + { + SafeDelete(mCountingIB); + mCountingIB = new StaticIndexBufferInterface(this); + ANGLE_TRY(mCountingIB->reserveBufferSpace(context, spaceNeeded, + gl::DrawElementsType::UnsignedInt)); + + void *mappedMemory = nullptr; + ANGLE_TRY(mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr)); + + unsigned int *data = static_cast<unsigned int *>(mappedMemory); + for (unsigned int i = 0; i < count; i++) + { + data[i] = i; + } + + ANGLE_TRY(mCountingIB->unmapBuffer(context)); + } + } + else + { + ANGLE_TRY_HR(GetImplAs<Context9>(context), E_OUTOFMEMORY, + "Could not create a counting index buffer for glDrawArraysInstanced."); + } + + *outIB = mCountingIB; + return angle::Result::Continue; +} + +angle::Result Renderer9::applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode) +{ + const gl::State &state = context->getState(); + d3d::Context *contextD3D = GetImplAs<ContextD3D>(context); + + // This method is called single-threaded. + ANGLE_TRY(ensureHLSLCompilerInitialized(contextD3D)); + + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(state.getProgram()); + VertexArray9 *vao = GetImplAs<VertexArray9>(state.getVertexArray()); + programD3D->updateCachedInputLayout(vao->getCurrentStateSerial(), state); + + ShaderExecutableD3D *vertexExe = nullptr; + ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(contextD3D, &vertexExe, nullptr)); + + const gl::Framebuffer *drawFramebuffer = state.getDrawFramebuffer(); + programD3D->updateCachedOutputLayout(context, drawFramebuffer); + + ShaderExecutableD3D *pixelExe = nullptr; + ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(contextD3D, &pixelExe, nullptr)); + + IDirect3DVertexShader9 *vertexShader = + (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr); + IDirect3DPixelShader9 *pixelShader = + (pixelExe ? GetAs<ShaderExecutable9>(pixelExe)->getPixelShader() : nullptr); + + if (vertexShader != mAppliedVertexShader) + { + mDevice->SetVertexShader(vertexShader); + mAppliedVertexShader = vertexShader; + } + + if (pixelShader != mAppliedPixelShader) + { + mDevice->SetPixelShader(pixelShader); + mAppliedPixelShader = pixelShader; + } + + // D3D9 has a quirk where creating multiple shaders with the same content + // can return the same shader pointer. Because GL programs store different data + // per-program, checking the program serial guarantees we upload fresh + // uniform data even if our shader pointers are the same. + // https://code.google.com/p/angleproject/issues/detail?id=661 + unsigned int programSerial = programD3D->getSerial(); + if (programSerial != mAppliedProgramSerial) + { + programD3D->dirtyAllUniforms(); + mStateManager.forceSetDXUniformsState(); + mAppliedProgramSerial = programSerial; + } + + applyUniforms(programD3D); + + // Driver uniforms + mStateManager.setShaderConstants(); + + return angle::Result::Continue; +} + +void Renderer9::applyUniforms(ProgramD3D *programD3D) +{ + // Skip updates if we're not dirty. Note that D3D9 cannot have compute or geometry. + if (!programD3D->anyShaderUniformsDirty()) + { + return; + } + + const auto &uniformArray = programD3D->getD3DUniforms(); + + for (const D3DUniform *targetUniform : uniformArray) + { + // Built-in uniforms must be skipped. + if (!targetUniform->isReferencedByShader(gl::ShaderType::Vertex) && + !targetUniform->isReferencedByShader(gl::ShaderType::Fragment)) + continue; + + const GLfloat *f = reinterpret_cast<const GLfloat *>(targetUniform->firstNonNullData()); + const GLint *i = reinterpret_cast<const GLint *>(targetUniform->firstNonNullData()); + + switch (targetUniform->typeInfo.type) + { + case GL_SAMPLER_2D: + case GL_SAMPLER_CUBE: + case GL_SAMPLER_EXTERNAL_OES: + case GL_SAMPLER_VIDEO_IMAGE_WEBGL: + break; + case GL_BOOL: + case GL_BOOL_VEC2: + case GL_BOOL_VEC3: + case GL_BOOL_VEC4: + applyUniformnbv(targetUniform, i); + break; + case GL_FLOAT: + case GL_FLOAT_VEC2: + case GL_FLOAT_VEC3: + case GL_FLOAT_VEC4: + case GL_FLOAT_MAT2: + case GL_FLOAT_MAT3: + case GL_FLOAT_MAT4: + applyUniformnfv(targetUniform, f); + break; + case GL_INT: + case GL_INT_VEC2: + case GL_INT_VEC3: + case GL_INT_VEC4: + applyUniformniv(targetUniform, i); + break; + default: + UNREACHABLE(); + } + } + + programD3D->markUniformsClean(); +} + +void Renderer9::applyUniformnfv(const D3DUniform *targetUniform, const GLfloat *v) +{ + if (targetUniform->isReferencedByShader(gl::ShaderType::Fragment)) + { + mDevice->SetPixelShaderConstantF( + targetUniform->mShaderRegisterIndexes[gl::ShaderType::Fragment], v, + targetUniform->registerCount); + } + + if (targetUniform->isReferencedByShader(gl::ShaderType::Vertex)) + { + mDevice->SetVertexShaderConstantF( + targetUniform->mShaderRegisterIndexes[gl::ShaderType::Vertex], v, + targetUniform->registerCount); + } +} + +void Renderer9::applyUniformniv(const D3DUniform *targetUniform, const GLint *v) +{ + ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9); + GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4]; + + for (unsigned int i = 0; i < targetUniform->registerCount; i++) + { + vector[i][0] = (GLfloat)v[4 * i + 0]; + vector[i][1] = (GLfloat)v[4 * i + 1]; + vector[i][2] = (GLfloat)v[4 * i + 2]; + vector[i][3] = (GLfloat)v[4 * i + 3]; + } + + applyUniformnfv(targetUniform, (GLfloat *)vector); +} + +void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v) +{ + ASSERT(targetUniform->registerCount <= MAX_VERTEX_CONSTANT_VECTORS_D3D9); + GLfloat vector[MAX_VERTEX_CONSTANT_VECTORS_D3D9][4]; + + for (unsigned int i = 0; i < targetUniform->registerCount; i++) + { + vector[i][0] = (v[4 * i + 0] == GL_FALSE) ? 0.0f : 1.0f; + vector[i][1] = (v[4 * i + 1] == GL_FALSE) ? 0.0f : 1.0f; + vector[i][2] = (v[4 * i + 2] == GL_FALSE) ? 0.0f : 1.0f; + vector[i][3] = (v[4 * i + 3] == GL_FALSE) ? 0.0f : 1.0f; + } + + applyUniformnfv(targetUniform, (GLfloat *)vector); +} + +void Renderer9::clear(const ClearParameters &clearParams, + const RenderTarget9 *colorRenderTarget, + const RenderTarget9 *depthStencilRenderTarget) +{ + // Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0 + ASSERT(clearParams.colorType == GL_FLOAT); + + // Clearing individual buffers other than buffer zero is not supported by Renderer9 and ES 2.0 + bool clearColor = clearParams.clearColor[0]; + for (unsigned int i = 0; i < clearParams.clearColor.size(); i++) + { + ASSERT(clearParams.clearColor[i] == clearColor); + } + + float depth = gl::clamp01(clearParams.depthValue); + DWORD stencil = clearParams.stencilValue & 0x000000FF; + + unsigned int stencilUnmasked = 0x0; + if (clearParams.clearStencil && depthStencilRenderTarget) + { + const gl::InternalFormat &depthStencilFormat = + gl::GetSizedInternalFormatInfo(depthStencilRenderTarget->getInternalFormat()); + if (depthStencilFormat.stencilBits > 0) + { + const d3d9::D3DFormat &d3dFormatInfo = + d3d9::GetD3DFormatInfo(depthStencilRenderTarget->getD3DFormat()); + stencilUnmasked = (0x1 << d3dFormatInfo.stencilBits) - 1; + } + } + + const bool needMaskedStencilClear = + clearParams.clearStencil && + (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked; + + bool needMaskedColorClear = false; + D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0); + if (clearColor) + { + ASSERT(colorRenderTarget != nullptr); + + const gl::InternalFormat &formatInfo = + gl::GetSizedInternalFormatInfo(colorRenderTarget->getInternalFormat()); + const d3d9::D3DFormat &d3dFormatInfo = + d3d9::GetD3DFormatInfo(colorRenderTarget->getD3DFormat()); + + color = + D3DCOLOR_ARGB(gl::unorm<8>((formatInfo.alphaBits == 0 && d3dFormatInfo.alphaBits > 0) + ? 1.0f + : clearParams.colorF.alpha), + gl::unorm<8>((formatInfo.redBits == 0 && d3dFormatInfo.redBits > 0) + ? 0.0f + : clearParams.colorF.red), + gl::unorm<8>((formatInfo.greenBits == 0 && d3dFormatInfo.greenBits > 0) + ? 0.0f + : clearParams.colorF.green), + gl::unorm<8>((formatInfo.blueBits == 0 && d3dFormatInfo.blueBits > 0) + ? 0.0f + : clearParams.colorF.blue)); + + const uint8_t colorMask = + gl::BlendStateExt::ColorMaskStorage::GetValueIndexed(0, clearParams.colorMask); + bool r, g, b, a; + gl::BlendStateExt::UnpackColorMask(colorMask, &r, &g, &b, &a); + if ((formatInfo.redBits > 0 && !r) || (formatInfo.greenBits > 0 && !g) || + (formatInfo.blueBits > 0 && !b) || (formatInfo.alphaBits > 0 && !a)) + { + needMaskedColorClear = true; + } + } + + if (needMaskedColorClear || needMaskedStencilClear) + { + // State which is altered in all paths from this point to the clear call is saved. + // State which is altered in only some paths will be flagged dirty in the case that + // that path is taken. + HRESULT hr; + if (mMaskedClearSavedState == nullptr) + { + hr = mDevice->BeginStateBlock(); + ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY); + + mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); + mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS); + mDevice->SetRenderState(D3DRS_ZENABLE, FALSE); + mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); + mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0); + mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0); + mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + mDevice->SetPixelShader(nullptr); + mDevice->SetVertexShader(nullptr); + mDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE); + mDevice->SetStreamSource(0, nullptr, 0, 0); + mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE); + mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); + mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR); + mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); + mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR); + mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color); + mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF); + + for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) + { + mDevice->SetStreamSourceFreq(i, 1); + } + + hr = mDevice->EndStateBlock(&mMaskedClearSavedState); + ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY); + } + + ASSERT(mMaskedClearSavedState != nullptr); + + if (mMaskedClearSavedState != nullptr) + { + hr = mMaskedClearSavedState->Capture(); + ASSERT(SUCCEEDED(hr)); + } + + mDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); + mDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS); + mDevice->SetRenderState(D3DRS_ZENABLE, FALSE); + mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + mDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); + mDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0); + + if (clearColor) + { + // clearParams.colorMask follows the same packing scheme as + // D3DCOLORWRITEENABLE_RED/GREEN/BLUE/ALPHA + mDevice->SetRenderState( + D3DRS_COLORWRITEENABLE, + gl::BlendStateExt::ColorMaskStorage::GetValueIndexed(0, clearParams.colorMask)); + } + else + { + mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0); + } + + if (stencilUnmasked != 0x0 && clearParams.clearStencil) + { + mDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE); + mDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE); + mDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS); + mDevice->SetRenderState(D3DRS_STENCILREF, stencil); + mDevice->SetRenderState(D3DRS_STENCILWRITEMASK, clearParams.stencilWriteMask); + mDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_REPLACE); + mDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_REPLACE); + mDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); + } + else + { + mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + } + + mDevice->SetPixelShader(nullptr); + mDevice->SetVertexShader(nullptr); + mDevice->SetFVF(D3DFVF_XYZRHW); + mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE); + mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); + mDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR); + mDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); + mDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR); + mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color); + mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF); + + for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) + { + mDevice->SetStreamSourceFreq(i, 1); + } + + int renderTargetWidth = mStateManager.getRenderTargetWidth(); + int renderTargetHeight = mStateManager.getRenderTargetHeight(); + + float quad[4][4]; // A quadrilateral covering the target, aligned to match the edges + quad[0][0] = -0.5f; + quad[0][1] = renderTargetHeight - 0.5f; + quad[0][2] = 0.0f; + quad[0][3] = 1.0f; + + quad[1][0] = renderTargetWidth - 0.5f; + quad[1][1] = renderTargetHeight - 0.5f; + quad[1][2] = 0.0f; + quad[1][3] = 1.0f; + + quad[2][0] = -0.5f; + quad[2][1] = -0.5f; + quad[2][2] = 0.0f; + quad[2][3] = 1.0f; + + quad[3][0] = renderTargetWidth - 0.5f; + quad[3][1] = -0.5f; + quad[3][2] = 0.0f; + quad[3][3] = 1.0f; + + startScene(); + mDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float[4])); + + if (clearParams.clearDepth) + { + mDevice->SetRenderState(D3DRS_ZENABLE, TRUE); + mDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE); + mDevice->Clear(0, nullptr, D3DCLEAR_ZBUFFER, color, depth, stencil); + } + + if (mMaskedClearSavedState != nullptr) + { + mMaskedClearSavedState->Apply(); + } + } + else if (clearColor || clearParams.clearDepth || clearParams.clearStencil) + { + DWORD dxClearFlags = 0; + if (clearColor) + { + dxClearFlags |= D3DCLEAR_TARGET; + } + if (clearParams.clearDepth) + { + dxClearFlags |= D3DCLEAR_ZBUFFER; + } + if (clearParams.clearStencil) + { + dxClearFlags |= D3DCLEAR_STENCIL; + } + + mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil); + } +} + +void Renderer9::markAllStateDirty() +{ + mAppliedRenderTargetSerial = 0; + mAppliedDepthStencilSerial = 0; + mDepthStencilInitialized = false; + mRenderTargetDescInitialized = false; + + mStateManager.forceSetRasterState(); + mStateManager.forceSetDepthStencilState(); + mStateManager.forceSetBlendState(); + mStateManager.forceSetScissorState(); + mStateManager.forceSetViewportState(); + + ASSERT(mCurVertexSamplerStates.size() == mCurVertexTextures.size()); + for (unsigned int i = 0; i < mCurVertexTextures.size(); i++) + { + mCurVertexSamplerStates[i].forceSet = true; + mCurVertexTextures[i] = angle::DirtyPointer; + } + + ASSERT(mCurPixelSamplerStates.size() == mCurPixelTextures.size()); + for (unsigned int i = 0; i < mCurPixelSamplerStates.size(); i++) + { + mCurPixelSamplerStates[i].forceSet = true; + mCurPixelTextures[i] = angle::DirtyPointer; + } + + mAppliedIBSerial = 0; + mAppliedVertexShader = nullptr; + mAppliedPixelShader = nullptr; + mAppliedProgramSerial = 0; + mStateManager.forceSetDXUniformsState(); + + mVertexDeclarationCache.markStateDirty(); +} + +void Renderer9::releaseDeviceResources() +{ + for (size_t i = 0; i < mEventQueryPool.size(); i++) + { + SafeRelease(mEventQueryPool[i]); + } + mEventQueryPool.clear(); + + SafeRelease(mMaskedClearSavedState); + + mVertexShaderCache.clear(); + mPixelShaderCache.clear(); + + SafeDelete(mBlit); + SafeDelete(mVertexDataManager); + SafeDelete(mIndexDataManager); + SafeDelete(mLineLoopIB); + SafeDelete(mCountingIB); + + for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++) + { + SafeDelete(mNullRenderTargetCache[i].renderTarget); + } +} + +// set notify to true to broadcast a message to all contexts of the device loss +bool Renderer9::testDeviceLost() +{ + HRESULT status = getDeviceStatusCode(); + return FAILED(status); +} + +HRESULT Renderer9::getDeviceStatusCode() +{ + HRESULT status = D3D_OK; + + if (mDeviceEx) + { + status = mDeviceEx->CheckDeviceState(nullptr); + } + else if (mDevice) + { + status = mDevice->TestCooperativeLevel(); + } + + return status; +} + +bool Renderer9::testDeviceResettable() +{ + // On D3D9Ex, DEVICELOST represents a hung device that needs to be restarted + // DEVICEREMOVED indicates the device has been stopped and must be recreated + switch (getDeviceStatusCode()) + { + case D3DERR_DEVICENOTRESET: + case D3DERR_DEVICEHUNG: + return true; + case D3DERR_DEVICELOST: + return (mDeviceEx != nullptr); + case D3DERR_DEVICEREMOVED: + ASSERT(mDeviceEx != nullptr); + return isRemovedDeviceResettable(); + default: + return false; + } +} + +bool Renderer9::resetDevice() +{ + releaseDeviceResources(); + + D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters(); + + HRESULT result = D3D_OK; + bool lost = testDeviceLost(); + bool removedDevice = (getDeviceStatusCode() == D3DERR_DEVICEREMOVED); + + // Device Removed is a feature which is only present with D3D9Ex + ASSERT(mDeviceEx != nullptr || !removedDevice); + + for (int attempts = 3; lost && attempts > 0; attempts--) + { + if (removedDevice) + { + // Device removed, which may trigger on driver reinstallation, + // may cause a longer wait other reset attempts before the + // system is ready to handle creating a new device. + Sleep(800); + lost = !resetRemovedDevice(); + } + else if (mDeviceEx) + { + Sleep(500); // Give the graphics driver some CPU time + result = mDeviceEx->ResetEx(&presentParameters, nullptr); + lost = testDeviceLost(); + } + else + { + result = mDevice->TestCooperativeLevel(); + while (result == D3DERR_DEVICELOST) + { + Sleep(100); // Give the graphics driver some CPU time + result = mDevice->TestCooperativeLevel(); + } + + if (result == D3DERR_DEVICENOTRESET) + { + result = mDevice->Reset(&presentParameters); + } + lost = testDeviceLost(); + } + } + + if (FAILED(result)) + { + ERR() << "Reset/ResetEx failed multiple times, " << gl::FmtHR(result); + return false; + } + + if (removedDevice && lost) + { + ERR() << "Device lost reset failed multiple times"; + return false; + } + + // If the device was removed, we already finished re-initialization in resetRemovedDevice + if (!removedDevice) + { + // reset device defaults + if (initializeDevice().isError()) + { + return false; + } + } + + return true; +} + +bool Renderer9::isRemovedDeviceResettable() const +{ + bool success = false; + +#if ANGLE_D3D9EX == ANGLE_ENABLED + IDirect3D9Ex *d3d9Ex = nullptr; + typedef HRESULT(WINAPI * Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex **); + Direct3DCreate9ExFunc Direct3DCreate9ExPtr = + reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex")); + + if (Direct3DCreate9ExPtr && SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &d3d9Ex))) + { + D3DCAPS9 deviceCaps; + HRESULT result = d3d9Ex->GetDeviceCaps(mAdapter, mDeviceType, &deviceCaps); + success = SUCCEEDED(result); + } + + SafeRelease(d3d9Ex); +#else + UNREACHABLE(); +#endif + + return success; +} + +bool Renderer9::resetRemovedDevice() +{ + // From http://msdn.microsoft.com/en-us/library/windows/desktop/bb172554(v=vs.85).aspx: + // The hardware adapter has been removed. Application must destroy the device, do enumeration of + // adapters and create another Direct3D device. If application continues rendering without + // calling Reset, the rendering calls will succeed. Applies to Direct3D 9Ex only. + release(); + return !initialize().isError(); +} + +VendorID Renderer9::getVendorId() const +{ + return static_cast<VendorID>(mAdapterIdentifier.VendorId); +} + +std::string Renderer9::getRendererDescription() const +{ + std::ostringstream rendererString; + + rendererString << mAdapterIdentifier.Description; + if (getShareHandleSupport()) + { + rendererString << " Direct3D9Ex"; + } + else + { + rendererString << " Direct3D9"; + } + + rendererString << " vs_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.VertexShaderVersion) << "_" + << D3DSHADER_VERSION_MINOR(mDeviceCaps.VertexShaderVersion); + rendererString << " ps_" << D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion) << "_" + << D3DSHADER_VERSION_MINOR(mDeviceCaps.PixelShaderVersion); + + return rendererString.str(); +} + +DeviceIdentifier Renderer9::getAdapterIdentifier() const +{ + DeviceIdentifier deviceIdentifier = {}; + deviceIdentifier.VendorId = static_cast<UINT>(mAdapterIdentifier.VendorId); + deviceIdentifier.DeviceId = static_cast<UINT>(mAdapterIdentifier.DeviceId); + deviceIdentifier.SubSysId = static_cast<UINT>(mAdapterIdentifier.SubSysId); + deviceIdentifier.Revision = static_cast<UINT>(mAdapterIdentifier.Revision); + deviceIdentifier.FeatureLevel = 0; + + return deviceIdentifier; +} + +unsigned int Renderer9::getReservedVertexUniformVectors() const +{ + return d3d9_gl::GetReservedVertexUniformVectors(); +} + +unsigned int Renderer9::getReservedFragmentUniformVectors() const +{ + return d3d9_gl::GetReservedFragmentUniformVectors(); +} + +bool Renderer9::getShareHandleSupport() const +{ + // PIX doesn't seem to support using share handles, so disable them. + return (mD3d9Ex != nullptr) && !gl::DebugAnnotationsActive(/*context=*/nullptr); +} + +int Renderer9::getMajorShaderModel() const +{ + return D3DSHADER_VERSION_MAJOR(mDeviceCaps.PixelShaderVersion); +} + +int Renderer9::getMinorShaderModel() const +{ + return D3DSHADER_VERSION_MINOR(mDeviceCaps.PixelShaderVersion); +} + +std::string Renderer9::getShaderModelSuffix() const +{ + return ""; +} + +DWORD Renderer9::getCapsDeclTypes() const +{ + return mDeviceCaps.DeclTypes; +} + +D3DPOOL Renderer9::getBufferPool(DWORD usage) const +{ + if (mD3d9Ex != nullptr) + { + return D3DPOOL_DEFAULT; + } + else + { + if (!(usage & D3DUSAGE_DYNAMIC)) + { + return D3DPOOL_MANAGED; + } + } + + return D3DPOOL_DEFAULT; +} + +angle::Result Renderer9::copyImage2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + RECT rect; + rect.left = sourceRect.x; + rect.top = sourceRect.y; + rect.right = sourceRect.x + sourceRect.width; + rect.bottom = sourceRect.y + sourceRect.height; + + return mBlit->copy2D(context, framebuffer, rect, destFormat, destOffset, storage, level); +} + +angle::Result Renderer9::copyImageCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) +{ + RECT rect; + rect.left = sourceRect.x; + rect.top = sourceRect.y; + rect.right = sourceRect.x + sourceRect.width; + rect.bottom = sourceRect.y + sourceRect.height; + + return mBlit->copyCube(context, framebuffer, rect, destFormat, destOffset, storage, target, + level); +} + +angle::Result Renderer9::copyImage3D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + // 3D textures are not available in the D3D9 backend. + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Renderer9::copyImage2DArray(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) +{ + // 2D array textures are not available in the D3D9 backend. + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Renderer9::copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + gl::TextureTarget srcTarget, + const gl::Box &sourceBox, + GLenum destFormat, + GLenum destType, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + RECT rect; + rect.left = sourceBox.x; + rect.top = sourceBox.y; + rect.right = sourceBox.x + sourceBox.width; + rect.bottom = sourceBox.y + sourceBox.height; + + return mBlit->copyTexture(context, source, sourceLevel, rect, destFormat, destOffset, storage, + destTarget, destLevel, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha); +} + +angle::Result Renderer9::copyCompressedTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + TextureStorage *storage, + GLint destLevel) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Renderer9::createRenderTarget(const gl::Context *context, + int width, + int height, + GLenum format, + GLsizei samples, + RenderTargetD3D **outRT) +{ + const d3d9::TextureFormat &d3d9FormatInfo = d3d9::GetTextureFormatInfo(format); + + const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format); + GLuint supportedSamples = textureCaps.getNearestSamples(samples); + + IDirect3DTexture9 *texture = nullptr; + IDirect3DSurface9 *renderTarget = nullptr; + if (width > 0 && height > 0) + { + bool requiresInitialization = false; + HRESULT result = D3DERR_INVALIDCALL; + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(format); + if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) + { + result = mDevice->CreateDepthStencilSurface( + width, height, d3d9FormatInfo.renderFormat, + gl_d3d9::GetMultisampleType(supportedSamples), 0, FALSE, &renderTarget, nullptr); + } + else + { + requiresInitialization = (d3d9FormatInfo.dataInitializerFunction != nullptr); + if (supportedSamples > 0) + { + result = mDevice->CreateRenderTarget(width, height, d3d9FormatInfo.renderFormat, + gl_d3d9::GetMultisampleType(supportedSamples), + 0, FALSE, &renderTarget, nullptr); + } + else + { + result = mDevice->CreateTexture( + width, height, 1, D3DUSAGE_RENDERTARGET, d3d9FormatInfo.texFormat, + getTexturePool(D3DUSAGE_RENDERTARGET), &texture, nullptr); + if (!FAILED(result)) + { + result = texture->GetSurfaceLevel(0, &renderTarget); + } + } + } + + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to create render target"); + + if (requiresInitialization) + { + // This format requires that the data be initialized before the render target can be + // used Unfortunately this requires a Get call on the d3d device but it is far better + // than having to mark the render target as lockable and copy data to the gpu. + IDirect3DSurface9 *prevRenderTarget = nullptr; + mDevice->GetRenderTarget(0, &prevRenderTarget); + mDevice->SetRenderTarget(0, renderTarget); + mDevice->Clear(0, nullptr, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 255), 0.0f, 0); + mDevice->SetRenderTarget(0, prevRenderTarget); + } + } + + *outRT = new TextureRenderTarget9(texture, 0, renderTarget, format, width, height, 1, + supportedSamples); + return angle::Result::Continue; +} + +angle::Result Renderer9::createRenderTargetCopy(const gl::Context *context, + RenderTargetD3D *source, + RenderTargetD3D **outRT) +{ + ASSERT(source != nullptr); + + RenderTargetD3D *newRT = nullptr; + ANGLE_TRY(createRenderTarget(context, source->getWidth(), source->getHeight(), + source->getInternalFormat(), source->getSamples(), &newRT)); + + RenderTarget9 *source9 = GetAs<RenderTarget9>(source); + RenderTarget9 *dest9 = GetAs<RenderTarget9>(newRT); + + HRESULT result = mDevice->StretchRect(source9->getSurface(), nullptr, dest9->getSurface(), + nullptr, D3DTEXF_NONE); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to copy render target"); + + *outRT = newRT; + return angle::Result::Continue; +} + +angle::Result Renderer9::loadExecutable(d3d::Context *context, + const uint8_t *function, + size_t length, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + ShaderExecutableD3D **outExecutable) +{ + // Transform feedback is not supported in ES2 or D3D9 + ASSERT(streamOutVaryings.empty()); + + switch (type) + { + case gl::ShaderType::Vertex: + { + IDirect3DVertexShader9 *vshader = nullptr; + ANGLE_TRY(createVertexShader(context, (DWORD *)function, length, &vshader)); + *outExecutable = new ShaderExecutable9(function, length, vshader); + } + break; + case gl::ShaderType::Fragment: + { + IDirect3DPixelShader9 *pshader = nullptr; + ANGLE_TRY(createPixelShader(context, (DWORD *)function, length, &pshader)); + *outExecutable = new ShaderExecutable9(function, length, pshader); + } + break; + default: + ANGLE_HR_UNREACHABLE(context); + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::compileToExecutable(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &shaderHLSL, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + const CompilerWorkaroundsD3D &workarounds, + ShaderExecutableD3D **outExectuable) +{ + // Transform feedback is not supported in ES2 or D3D9 + ASSERT(streamOutVaryings.empty()); + + std::stringstream profileStream; + + switch (type) + { + case gl::ShaderType::Vertex: + profileStream << "vs"; + break; + case gl::ShaderType::Fragment: + profileStream << "ps"; + break; + default: + ANGLE_HR_UNREACHABLE(context); + } + + profileStream << "_" << ((getMajorShaderModel() >= 3) ? 3 : 2); + profileStream << "_" + << "0"; + + std::string profile = profileStream.str(); + + UINT flags = ANGLE_COMPILE_OPTIMIZATION_LEVEL; + + if (workarounds.skipOptimization) + { + flags = D3DCOMPILE_SKIP_OPTIMIZATION; + } + else if (workarounds.useMaxOptimization) + { + flags = D3DCOMPILE_OPTIMIZATION_LEVEL3; + } + + if (gl::DebugAnnotationsActive(/*context=*/nullptr)) + { +#ifndef NDEBUG + flags = D3DCOMPILE_SKIP_OPTIMIZATION; +#endif + + flags |= D3DCOMPILE_DEBUG; + } + + // Sometimes D3DCompile will fail with the default compilation flags for complicated shaders + // when it would otherwise pass with alternative options. Try the default flags first and if + // compilation fails, try some alternatives. + std::vector<CompileConfig> configs; + configs.push_back(CompileConfig(flags, "default")); + configs.push_back(CompileConfig(flags | D3DCOMPILE_AVOID_FLOW_CONTROL, "avoid flow control")); + configs.push_back(CompileConfig(flags | D3DCOMPILE_PREFER_FLOW_CONTROL, "prefer flow control")); + + ID3DBlob *binary = nullptr; + std::string debugInfo; + angle::Result error = mCompiler.compileToBinary(context, infoLog, shaderHLSL, profile, configs, + nullptr, &binary, &debugInfo); + ANGLE_TRY(error); + + // It's possible that binary is NULL if the compiler failed in all configurations. Set the + // executable to NULL and return GL_NO_ERROR to signify that there was a link error but the + // internal state is still OK. + if (!binary) + { + *outExectuable = nullptr; + return angle::Result::Continue; + } + + error = loadExecutable(context, reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()), + binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers, + outExectuable); + + SafeRelease(binary); + ANGLE_TRY(error); + + if (!debugInfo.empty()) + { + (*outExectuable)->appendDebugInfo(debugInfo); + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::ensureHLSLCompilerInitialized(d3d::Context *context) +{ + return mCompiler.ensureInitialized(context); +} + +UniformStorageD3D *Renderer9::createUniformStorage(size_t storageSize) +{ + return new UniformStorageD3D(storageSize); +} + +angle::Result Renderer9::boxFilter(Context9 *context9, + IDirect3DSurface9 *source, + IDirect3DSurface9 *dest) +{ + return mBlit->boxFilter(context9, source, dest); +} + +D3DPOOL Renderer9::getTexturePool(DWORD usage) const +{ + if (mD3d9Ex != nullptr) + { + return D3DPOOL_DEFAULT; + } + else + { + if (!(usage & (D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_RENDERTARGET))) + { + return D3DPOOL_MANAGED; + } + } + + return D3DPOOL_DEFAULT; +} + +angle::Result Renderer9::copyToRenderTarget(const gl::Context *context, + IDirect3DSurface9 *dest, + IDirect3DSurface9 *source, + bool fromManaged) +{ + ASSERT(source && dest); + + Context9 *context9 = GetImplAs<Context9>(context); + + HRESULT result = D3DERR_OUTOFVIDEOMEMORY; + + if (fromManaged) + { + D3DSURFACE_DESC desc; + source->GetDesc(&desc); + + IDirect3DSurface9 *surf = 0; + result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, + D3DPOOL_SYSTEMMEM, &surf, nullptr); + + if (SUCCEEDED(result)) + { + ANGLE_TRY(Image9::CopyLockableSurfaces(context9, surf, source)); + result = mDevice->UpdateSurface(surf, nullptr, dest, nullptr); + SafeRelease(surf); + } + } + else + { + endScene(); + result = mDevice->StretchRect(source, nullptr, dest, nullptr, D3DTEXF_NONE); + } + + ANGLE_TRY_HR(context9, result, "Failed to blit internal texture"); + return angle::Result::Continue; +} + +RendererClass Renderer9::getRendererClass() const +{ + return RENDERER_D3D9; +} + +ImageD3D *Renderer9::createImage() +{ + return new Image9(this); +} + +ExternalImageSiblingImpl *Renderer9::createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) +{ + UNREACHABLE(); + return nullptr; +} + +angle::Result Renderer9::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src) +{ + Image9 *src9 = GetAs<Image9>(src); + Image9 *dst9 = GetAs<Image9>(dest); + return Image9::GenerateMipmap(GetImplAs<Context9>(context), dst9, src9); +} + +angle::Result Renderer9::generateMipmapUsingD3D(const gl::Context *context, + TextureStorage *storage, + const gl::TextureState &textureState) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result Renderer9::copyImage(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + Image9 *dest9 = GetAs<Image9>(dest); + Image9 *src9 = GetAs<Image9>(source); + return Image9::CopyImage(context, dest9, src9, sourceBox.toRect(), destOffset, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); +} + +TextureStorage *Renderer9::createTextureStorage2D(SwapChainD3D *swapChain, const std::string &label) +{ + SwapChain9 *swapChain9 = GetAs<SwapChain9>(swapChain); + return new TextureStorage9_2D(this, swapChain9, label); +} + +TextureStorage *Renderer9::createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D, + const std::string &label) +{ + return new TextureStorage9_EGLImage(this, eglImage, GetAs<RenderTarget9>(renderTargetD3D), + label); +} + +TextureStorage *Renderer9::createTextureStorageBuffer( + const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) +{ + UNREACHABLE(); + return nullptr; +} + +TextureStorage *Renderer9::createTextureStorageExternal( + egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc, + const std::string &label) +{ + UNIMPLEMENTED(); + return nullptr; +} + +TextureStorage *Renderer9::createTextureStorage2D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) +{ + return new TextureStorage9_2D(this, internalformat, bindFlags.renderTarget, width, height, + levels, label); +} + +TextureStorage *Renderer9::createTextureStorageCube(GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) +{ + return new TextureStorage9_Cube(this, internalformat, bindFlags.renderTarget, size, levels, + hintLevelZeroOnly, label); +} + +TextureStorage *Renderer9::createTextureStorage3D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) +{ + // 3D textures are not supported by the D3D9 backend. + UNREACHABLE(); + + return nullptr; +} + +TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) +{ + // 2D array textures are not supported by the D3D9 backend. + UNREACHABLE(); + + return nullptr; +} + +TextureStorage *Renderer9::createTextureStorage2DMultisample(GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) +{ + // 2D multisampled textures are not supported by the D3D9 backend. + UNREACHABLE(); + + return nullptr; +} + +TextureStorage *Renderer9::createTextureStorage2DMultisampleArray(GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) +{ + // 2D multisampled textures are not supported by the D3D9 backend. + UNREACHABLE(); + + return nullptr; +} + +bool Renderer9::getLUID(LUID *adapterLuid) const +{ + adapterLuid->HighPart = 0; + adapterLuid->LowPart = 0; + + if (mD3d9Ex) + { + mD3d9Ex->GetAdapterLUID(mAdapter, adapterLuid); + return true; + } + + return false; +} + +VertexConversionType Renderer9::getVertexConversionType(angle::FormatID vertexFormatID) const +{ + return d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatID).conversionType; +} + +GLenum Renderer9::getVertexComponentType(angle::FormatID vertexFormatID) const +{ + return d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatID).componentType; +} + +angle::Result Renderer9::getVertexSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *bytesRequiredOut) const +{ + if (!attrib.enabled) + { + *bytesRequiredOut = 16u; + return angle::Result::Continue; + } + + angle::FormatID vertexFormatID = gl::GetVertexFormatID(attrib, gl::VertexAttribType::Float); + const d3d9::VertexFormat &d3d9VertexInfo = + d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatID); + + unsigned int elementCount = 0; + const unsigned int divisor = binding.getDivisor(); + if (instances == 0 || divisor == 0) + { + elementCount = static_cast<unsigned int>(count); + } + else + { + // Round up to divisor, if possible + elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), divisor); + } + + bool check = (d3d9VertexInfo.outputElementSize > + std::numeric_limits<unsigned int>::max() / elementCount); + ANGLE_CHECK(GetImplAs<Context9>(context), !check, + "New vertex buffer size would result in an overflow.", GL_OUT_OF_MEMORY); + + *bytesRequiredOut = static_cast<unsigned int>(d3d9VertexInfo.outputElementSize) * elementCount; + return angle::Result::Continue; +} + +void Renderer9::generateCaps(gl::Caps *outCaps, + gl::TextureCapsMap *outTextureCaps, + gl::Extensions *outExtensions, + gl::Limitations *outLimitations) const +{ + d3d9_gl::GenerateCaps(mD3d9, mDevice, mDeviceType, mAdapter, outCaps, outTextureCaps, + outExtensions, outLimitations); +} + +void Renderer9::initializeFeatures(angle::FeaturesD3D *features) const +{ + if (!mDisplay->getState().featuresAllDisabled) + { + d3d9::InitializeFeatures(features); + } + ApplyFeatureOverrides(features, mDisplay->getState()); +} + +void Renderer9::initializeFrontendFeatures(angle::FrontendFeatures *features) const {} + +DeviceImpl *Renderer9::createEGLDevice() +{ + return new DeviceD3D(EGL_D3D9_DEVICE_ANGLE, mDevice); +} + +Renderer9::CurSamplerState::CurSamplerState() + : forceSet(true), baseLevel(std::numeric_limits<size_t>::max()), samplerState() +{} + +angle::Result Renderer9::genericDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances) +{ + const gl::State &state = context->getState(); + gl::Program *program = context->getState().getProgram(); + ASSERT(program != nullptr); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + bool usesPointSize = programD3D->usesPointSize(); + + programD3D->updateSamplerMapping(); + + if (!applyPrimitiveType(mode, count, usesPointSize)) + { + return angle::Result::Continue; + } + + ANGLE_TRY(updateState(context, mode)); + ANGLE_TRY(applyTextures(context)); + ANGLE_TRY(applyShaders(context, mode)); + + if (!skipDraw(state, mode)) + { + ANGLE_TRY(drawElementsImpl(context, mode, count, type, indices, instances)); + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::genericDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instances) +{ + gl::Program *program = context->getState().getProgram(); + ASSERT(program != nullptr); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + bool usesPointSize = programD3D->usesPointSize(); + + programD3D->updateSamplerMapping(); + + if (!applyPrimitiveType(mode, count, usesPointSize)) + { + return angle::Result::Continue; + } + + ANGLE_TRY(updateState(context, mode)); + ANGLE_TRY(applyVertexBuffer(context, mode, first, count, instances, nullptr)); + ANGLE_TRY(applyTextures(context)); + ANGLE_TRY(applyShaders(context, mode)); + + if (!skipDraw(context->getState(), mode)) + { + ANGLE_TRY(drawArraysImpl(context, mode, first, count, instances)); + } + + return angle::Result::Continue; +} + +FramebufferImpl *Renderer9::createDefaultFramebuffer(const gl::FramebufferState &state) +{ + return new Framebuffer9(state, this); +} + +gl::Version Renderer9::getMaxSupportedESVersion() const +{ + return gl::Version(2, 0); +} + +gl::Version Renderer9::getMaxConformantESVersion() const +{ + return gl::Version(2, 0); +} + +angle::Result Renderer9::clearRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget, + const gl::ColorF &clearColorValue, + const float clearDepthValue, + const unsigned int clearStencilValue) +{ + D3DCOLOR color = + D3DCOLOR_ARGB(gl::unorm<8>(clearColorValue.alpha), gl::unorm<8>(clearColorValue.red), + gl::unorm<8>(clearColorValue.green), gl::unorm<8>(clearColorValue.blue)); + float depth = clearDepthValue; + DWORD stencil = clearStencilValue & 0x000000FF; + + unsigned int renderTargetSerial = renderTarget->getSerial(); + RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTarget); + IDirect3DSurface9 *renderTargetSurface = renderTarget9->getSurface(); + ASSERT(renderTargetSurface); + + DWORD dxClearFlags = 0; + + const gl::InternalFormat &internalFormatInfo = + gl::GetSizedInternalFormatInfo(renderTarget->getInternalFormat()); + if (internalFormatInfo.depthBits > 0 || internalFormatInfo.stencilBits > 0) + { + dxClearFlags = D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL; + if (mAppliedDepthStencilSerial != renderTargetSerial) + { + mDevice->SetDepthStencilSurface(renderTargetSurface); + } + } + else + { + dxClearFlags = D3DCLEAR_TARGET; + if (mAppliedRenderTargetSerial != renderTargetSerial) + { + mDevice->SetRenderTarget(0, renderTargetSurface); + } + } + SafeRelease(renderTargetSurface); + + D3DVIEWPORT9 viewport; + viewport.X = 0; + viewport.Y = 0; + viewport.Width = renderTarget->getWidth(); + viewport.Height = renderTarget->getHeight(); + mDevice->SetViewport(&viewport); + + mDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE); + + mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil); + + markAllStateDirty(); + + return angle::Result::Continue; +} + +bool Renderer9::canSelectViewInVertexShader() const +{ + return false; +} + +// For each Direct3D sampler of either the pixel or vertex stage, +// looks up the corresponding OpenGL texture image unit and texture type, +// and sets the texture and its addressing/filtering state (or NULL when inactive). +// Sampler mapping needs to be up-to-date on the program object before this is called. +angle::Result Renderer9::applyTextures(const gl::Context *context, gl::ShaderType shaderType) +{ + const auto &glState = context->getState(); + const auto &caps = context->getCaps(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram()); + + ASSERT(!programD3D->isSamplerMappingDirty()); + + // TODO(jmadill): Use the Program's sampler bindings. + const gl::ActiveTexturesCache &activeTextures = glState.getActiveTexturesCache(); + + const gl::RangeUI samplerRange = programD3D->getUsedSamplerRange(shaderType); + for (unsigned int samplerIndex = samplerRange.low(); samplerIndex < samplerRange.high(); + samplerIndex++) + { + GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, caps); + ASSERT(textureUnit != -1); + gl::Texture *texture = activeTextures[textureUnit]; + + // A nullptr texture indicates incomplete. + if (texture) + { + gl::Sampler *samplerObject = glState.getSampler(textureUnit); + + const gl::SamplerState &samplerState = + samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState(); + + ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, texture, samplerState)); + ANGLE_TRY(setTexture(context, shaderType, samplerIndex, texture)); + } + else + { + gl::TextureType textureType = + programD3D->getSamplerTextureType(shaderType, samplerIndex); + + // Texture is not sampler complete or it is in use by the framebuffer. Bind the + // incomplete texture. + gl::Texture *incompleteTexture = nullptr; + ANGLE_TRY(getIncompleteTexture(context, textureType, &incompleteTexture)); + ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture, + incompleteTexture->getSamplerState())); + ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture)); + } + } + + // Set all the remaining textures to NULL + int samplerCount = (shaderType == gl::ShaderType::Fragment) + ? caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment] + : caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]; + + // TODO(jmadill): faster way? + for (int samplerIndex = samplerRange.high(); samplerIndex < samplerCount; samplerIndex++) + { + ANGLE_TRY(setTexture(context, shaderType, samplerIndex, nullptr)); + } + + return angle::Result::Continue; +} + +angle::Result Renderer9::applyTextures(const gl::Context *context) +{ + ANGLE_TRY(applyTextures(context, gl::ShaderType::Vertex)); + ANGLE_TRY(applyTextures(context, gl::ShaderType::Fragment)); + return angle::Result::Continue; +} + +angle::Result Renderer9::getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) +{ + return GetImplAs<Context9>(context)->getIncompleteTexture(context, type, textureOut); +} + +angle::Result Renderer9::ensureVertexDataManagerInitialized(const gl::Context *context) +{ + if (!mVertexDataManager) + { + mVertexDataManager = new VertexDataManager(this); + ANGLE_TRY(mVertexDataManager->initialize(context)); + } + + return angle::Result::Continue; +} + +std::string Renderer9::getVendorString() const +{ + return GetVendorString(getVendorId()); +} + +std::string Renderer9::getVersionString(bool includeFullVersion) const +{ + std::ostringstream versionString; + std::string driverName(mAdapterIdentifier.Driver); + if (!driverName.empty()) + { + versionString << mAdapterIdentifier.Driver; + } + else + { + versionString << "D3D9"; + } + + if (includeFullVersion) + { + versionString << " -"; + versionString << GetDriverVersionString(mAdapterIdentifier.DriverVersion); + } + + return versionString.str(); +} + +RendererD3D *CreateRenderer9(egl::Display *display) +{ + return new Renderer9(display); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.h new file mode 100644 index 0000000000..67a20f56ba --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/Renderer9.h @@ -0,0 +1,586 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Renderer9.h: Defines a back-end specific class for the D3D9 renderer. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_RENDERER9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_RENDERER9_H_ + +#include "common/angleutils.h" +#include "common/mathutil.h" +#include "libANGLE/renderer/d3d/HLSLCompiler.h" +#include "libANGLE/renderer/d3d/RenderTargetD3D.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" +#include "libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h" +#include "libANGLE/renderer/d3d/d3d9/ShaderCache.h" +#include "libANGLE/renderer/d3d/d3d9/StateManager9.h" +#include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h" +#include "libANGLE/renderer/driver_utils.h" + +namespace gl +{ +class FramebufferAttachment; +} + +namespace egl +{ +class AttributeMap; +} + +namespace rx +{ +class Blit9; +class Context9; +class IndexDataManager; +class ProgramD3D; +class RenderTarget9; +class StreamingIndexBufferInterface; +class StaticIndexBufferInterface; +class VertexDataManager; +struct ClearParameters; +struct D3DUniform; +struct TranslatedAttribute; + +class Renderer9 : public RendererD3D +{ + public: + explicit Renderer9(egl::Display *display); + ~Renderer9() override; + + egl::Error initialize() override; + bool resetDevice() override; + + egl::ConfigSet generateConfigs() override; + void generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const override; + + void startScene(); + void endScene(); + + angle::Result flush(const gl::Context *context); + angle::Result finish(const gl::Context *context); + + bool isValidNativeWindow(EGLNativeWindowType window) const override; + NativeWindowD3D *createNativeWindow(EGLNativeWindowType window, + const egl::Config *config, + const egl::AttributeMap &attribs) const override; + + SwapChainD3D *createSwapChain(NativeWindowD3D *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation, + EGLint samples) override; + egl::Error getD3DTextureInfo(const egl::Config *configuration, + IUnknown *d3dTexture, + const egl::AttributeMap &attribs, + EGLint *width, + EGLint *height, + GLsizei *samples, + gl::Format *glFormat, + const angle::Format **angleFormat, + UINT *arraySlice) const override; + egl::Error validateShareHandle(const egl::Config *config, + HANDLE shareHandle, + const egl::AttributeMap &attribs) const override; + + ContextImpl *createContext(const gl::State &state, gl::ErrorSet *errorSet) override; + + angle::Result allocateEventQuery(const gl::Context *context, IDirect3DQuery9 **outQuery); + void freeEventQuery(IDirect3DQuery9 *query); + + // resource creation + angle::Result createVertexShader(d3d::Context *context, + const DWORD *function, + size_t length, + IDirect3DVertexShader9 **outShader); + angle::Result createPixelShader(d3d::Context *context, + const DWORD *function, + size_t length, + IDirect3DPixelShader9 **outShader); + HRESULT createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer); + HRESULT createIndexBuffer(UINT Length, + DWORD Usage, + D3DFORMAT Format, + IDirect3DIndexBuffer9 **ppIndexBuffer); + angle::Result setSamplerState(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture, + const gl::SamplerState &sampler); + angle::Result setTexture(const gl::Context *context, + gl::ShaderType type, + int index, + gl::Texture *texture); + + angle::Result updateState(const gl::Context *context, gl::PrimitiveMode drawMode); + + void setScissorRectangle(const gl::Rectangle &scissor, bool enabled); + void setViewport(const gl::Rectangle &viewport, + float zNear, + float zFar, + gl::PrimitiveMode drawMode, + GLenum frontFace, + bool ignoreViewport); + + angle::Result applyRenderTarget(const gl::Context *context, + const RenderTarget9 *colorRenderTarget, + const RenderTarget9 *depthStencilRenderTarget); + void applyUniforms(ProgramD3D *programD3D); + bool applyPrimitiveType(gl::PrimitiveMode primitiveType, + GLsizei elementCount, + bool usesPointSize); + angle::Result applyVertexBuffer(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instances, + TranslatedIndexData *indexInfo); + angle::Result applyIndexBuffer(const gl::Context *context, + const void *indices, + GLsizei count, + gl::PrimitiveMode mode, + gl::DrawElementsType type, + TranslatedIndexData *indexInfo); + + void clear(const ClearParameters &clearParams, + const RenderTarget9 *colorRenderTarget, + const RenderTarget9 *depthStencilRenderTarget); + + void markAllStateDirty(); + + // lost device + bool testDeviceLost() override; + bool testDeviceResettable() override; + + VendorID getVendorId() const; + DeviceIdentifier getAdapterIdentifier() const override; + + IDirect3DDevice9 *getDevice() { return mDevice; } + void *getD3DDevice() override; + + unsigned int getReservedVertexUniformVectors() const; + unsigned int getReservedFragmentUniformVectors() const; + + bool getShareHandleSupport() const; + + int getMajorShaderModel() const override; + int getMinorShaderModel() const override; + std::string getShaderModelSuffix() const override; + + DWORD getCapsDeclTypes() const; + + // Pixel operations + angle::Result copyImage2D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + angle::Result copyImageCube(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget target, + GLint level) override; + angle::Result copyImage3D(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + angle::Result copyImage2DArray(const gl::Context *context, + const gl::Framebuffer *framebuffer, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint level) override; + + angle::Result copyTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + gl::TextureTarget srcTarget, + const gl::Box &sourceBox, + GLenum destFormat, + GLenum destType, + const gl::Offset &destOffset, + TextureStorage *storage, + gl::TextureTarget destTarget, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) override; + angle::Result copyCompressedTexture(const gl::Context *context, + const gl::Texture *source, + GLint sourceLevel, + TextureStorage *storage, + GLint destLevel) override; + + // RenderTarget creation + angle::Result createRenderTarget(const gl::Context *context, + int width, + int height, + GLenum format, + GLsizei samples, + RenderTargetD3D **outRT) override; + angle::Result createRenderTargetCopy(const gl::Context *context, + RenderTargetD3D *source, + RenderTargetD3D **outRT) override; + + // Shader operations + angle::Result loadExecutable(d3d::Context *context, + const uint8_t *function, + size_t length, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + ShaderExecutableD3D **outExecutable) override; + angle::Result compileToExecutable(d3d::Context *context, + gl::InfoLog &infoLog, + const std::string &shaderHLSL, + gl::ShaderType type, + const std::vector<D3DVarying> &streamOutVaryings, + bool separatedOutputBuffers, + const CompilerWorkaroundsD3D &workarounds, + ShaderExecutableD3D **outExectuable) override; + angle::Result ensureHLSLCompilerInitialized(d3d::Context *context) override; + + UniformStorageD3D *createUniformStorage(size_t storageSize) override; + + // Image operations + ImageD3D *createImage() override; + ExternalImageSiblingImpl *createExternalImageSibling(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attribs) override; + angle::Result generateMipmap(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source) override; + angle::Result generateMipmapUsingD3D(const gl::Context *context, + TextureStorage *storage, + const gl::TextureState &textureState) override; + angle::Result copyImage(const gl::Context *context, + ImageD3D *dest, + ImageD3D *source, + const gl::Box &sourceBox, + const gl::Offset &destOffset, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) override; + TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain, + const std::string &label) override; + TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D, + const std::string &label) override; + + TextureStorage *createTextureStorageBuffer(const gl::OffsetBindingPointer<gl::Buffer> &buffer, + GLenum internalFormat, + const std::string &label) override; + + TextureStorage *createTextureStorageExternal(egl::Stream *stream, + const egl::Stream::GLTextureDescription &desc, + const std::string &label) override; + + TextureStorage *createTextureStorage2D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + int levels, + const std::string &label, + bool hintLevelZeroOnly) override; + TextureStorage *createTextureStorageCube(GLenum internalformat, + BindFlags bindFlags, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) override; + TextureStorage *createTextureStorage3D(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) override; + TextureStorage *createTextureStorage2DArray(GLenum internalformat, + BindFlags bindFlags, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + const std::string &label) override; + + TextureStorage *createTextureStorage2DMultisample(GLenum internalformat, + GLsizei width, + GLsizei height, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) override; + TextureStorage *createTextureStorage2DMultisampleArray(GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + int levels, + int samples, + bool fixedSampleLocations, + const std::string &label) override; + + // Buffer creation + VertexBuffer *createVertexBuffer() override; + IndexBuffer *createIndexBuffer() override; + + // Stream Creation + StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType, + const egl::AttributeMap &attribs) override; + + // Buffer-to-texture and Texture-to-buffer copies + bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override; + angle::Result fastCopyBufferToTexture(const gl::Context *context, + const gl::PixelUnpackState &unpack, + gl::Buffer *unpackBuffer, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) override; + + // D3D9-renderer specific methods + angle::Result boxFilter(Context9 *context9, IDirect3DSurface9 *source, IDirect3DSurface9 *dest); + + D3DPOOL getTexturePool(DWORD usage) const; + + bool getLUID(LUID *adapterLuid) const override; + VertexConversionType getVertexConversionType(angle::FormatID vertexFormatID) const override; + GLenum getVertexComponentType(angle::FormatID vertexFormatID) const override; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + angle::Result getVertexSpaceRequired(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + size_t count, + GLsizei instances, + GLuint baseInstance, + unsigned int *bytesRequiredOut) const override; + + angle::Result copyToRenderTarget(const gl::Context *context, + IDirect3DSurface9 *dest, + IDirect3DSurface9 *source, + bool fromManaged); + + RendererClass getRendererClass() const override; + + D3DDEVTYPE getD3D9DeviceType() const { return mDeviceType; } + + DeviceImpl *createEGLDevice() override; + + StateManager9 *getStateManager() { return &mStateManager; } + + angle::Result genericDrawArrays(const gl::Context *context, + gl::PrimitiveMode mode, + GLint first, + GLsizei count, + GLsizei instances); + + angle::Result genericDrawElements(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances); + + // Necessary hack for default framebuffers in D3D. + FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override; + + DebugAnnotator9 *getAnnotator() { return &mAnnotator; } + + gl::Version getMaxSupportedESVersion() const override; + gl::Version getMaxConformantESVersion() const override; + + angle::Result clearRenderTarget(const gl::Context *context, + RenderTargetD3D *renderTarget, + const gl::ColorF &clearColorValue, + const float clearDepthValue, + const unsigned int clearStencilValue) override; + + bool canSelectViewInVertexShader() const override; + + angle::Result getIncompleteTexture(const gl::Context *context, + gl::TextureType type, + gl::Texture **textureOut) override; + + angle::Result ensureVertexDataManagerInitialized(const gl::Context *context); + + void setGlobalDebugAnnotator() override; + + std::string getRendererDescription() const override; + std::string getVendorString() const override; + std::string getVersionString(bool includeFullVersion) const override; + + private: + angle::Result drawArraysImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLint startVertex, + GLsizei count, + GLsizei instances); + angle::Result drawElementsImpl(const gl::Context *context, + gl::PrimitiveMode mode, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + GLsizei instances); + + angle::Result applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode); + + angle::Result applyTextures(const gl::Context *context); + angle::Result applyTextures(const gl::Context *context, gl::ShaderType shaderType); + + void generateCaps(gl::Caps *outCaps, + gl::TextureCapsMap *outTextureCaps, + gl::Extensions *outExtensions, + gl::Limitations *outLimitations) const override; + + void initializeFeatures(angle::FeaturesD3D *features) const override; + + void initializeFrontendFeatures(angle::FrontendFeatures *features) const override; + + angle::Result setBlendDepthRasterStates(const gl::Context *context, gl::PrimitiveMode drawMode); + + void release(); + + void applyUniformnfv(const D3DUniform *targetUniform, const GLfloat *v); + void applyUniformniv(const D3DUniform *targetUniform, const GLint *v); + void applyUniformnbv(const D3DUniform *targetUniform, const GLint *v); + + angle::Result drawLineLoop(const gl::Context *context, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + int minIndex, + gl::Buffer *elementArrayBuffer); + angle::Result drawIndexedPoints(const gl::Context *context, + GLsizei count, + gl::DrawElementsType type, + const void *indices, + int minIndex, + gl::Buffer *elementArrayBuffer); + + angle::Result getCountingIB(const gl::Context *context, + size_t count, + StaticIndexBufferInterface **outIB); + + angle::Result getNullColorRenderTarget(const gl::Context *context, + const RenderTarget9 *depthRenderTarget, + const RenderTarget9 **outColorRenderTarget); + + D3DPOOL getBufferPool(DWORD usage) const; + + HMODULE mD3d9Module; + + egl::Error initializeDevice(); + D3DPRESENT_PARAMETERS getDefaultPresentParameters(); + void releaseDeviceResources(); + + HRESULT getDeviceStatusCode(); + bool isRemovedDeviceResettable() const; + bool resetRemovedDevice(); + + UINT mAdapter; + D3DDEVTYPE mDeviceType; + IDirect3D9 *mD3d9; // Always valid after successful initialization. + IDirect3D9Ex *mD3d9Ex; // Might be null if D3D9Ex is not supported. + IDirect3DDevice9 *mDevice; + IDirect3DDevice9Ex *mDeviceEx; // Might be null if D3D9Ex is not supported. + + HLSLCompiler mCompiler; + + Blit9 *mBlit; + + HWND mDeviceWindow; + + D3DCAPS9 mDeviceCaps; + D3DADAPTER_IDENTIFIER9 mAdapterIdentifier; + + D3DPRIMITIVETYPE mPrimitiveType; + int mPrimitiveCount; + GLsizei mRepeatDraw; + + bool mSceneStarted; + + bool mVertexTextureSupport; + + // current render target states + unsigned int mAppliedRenderTargetSerial; + unsigned int mAppliedDepthStencilSerial; + bool mDepthStencilInitialized; + bool mRenderTargetDescInitialized; + + IDirect3DStateBlock9 *mMaskedClearSavedState; + + StateManager9 mStateManager; + + // Currently applied sampler states + struct CurSamplerState + { + CurSamplerState(); + + bool forceSet; + size_t baseLevel; + gl::SamplerState samplerState; + }; + std::vector<CurSamplerState> mCurVertexSamplerStates; + std::vector<CurSamplerState> mCurPixelSamplerStates; + + // Currently applied textures + std::vector<uintptr_t> mCurVertexTextures; + std::vector<uintptr_t> mCurPixelTextures; + + unsigned int mAppliedIBSerial; + IDirect3DVertexShader9 *mAppliedVertexShader; + IDirect3DPixelShader9 *mAppliedPixelShader; + unsigned int mAppliedProgramSerial; + + // A pool of event queries that are currently unused. + std::vector<IDirect3DQuery9 *> mEventQueryPool; + VertexShaderCache mVertexShaderCache; + PixelShaderCache mPixelShaderCache; + + VertexDataManager *mVertexDataManager; + VertexDeclarationCache mVertexDeclarationCache; + + IndexDataManager *mIndexDataManager; + StreamingIndexBufferInterface *mLineLoopIB; + StaticIndexBufferInterface *mCountingIB; + + enum + { + NUM_NULL_COLORBUFFER_CACHE_ENTRIES = 12 + }; + struct NullRenderTargetCacheEntry + { + UINT lruCount; + int width; + int height; + RenderTarget9 *renderTarget; + }; + + std::array<NullRenderTargetCacheEntry, NUM_NULL_COLORBUFFER_CACHE_ENTRIES> + mNullRenderTargetCache; + UINT mMaxNullColorbufferLRU; + + std::vector<TranslatedAttribute> mTranslatedAttribCache; + + DebugAnnotator9 mAnnotator; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_RENDERER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h new file mode 100644 index 0000000000..bd1a4cf269 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h @@ -0,0 +1,110 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderCache: Defines rx::ShaderCache, a cache of Direct3D shader objects +// keyed by their byte code. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_SHADERCACHE_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_SHADERCACHE_H_ + +#include "libANGLE/Error.h" + +#include "common/debug.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" + +#include <cstddef> +#include <mutex> +#include <string> +#include <unordered_map> + +namespace rx +{ +template <typename ShaderObject> +class ShaderCache : angle::NonCopyable +{ + public: + ShaderCache() : mDevice(nullptr) {} + + ~ShaderCache() + { + // Call clear while the device is still valid. + ASSERT(mMap.empty()); + } + + void initialize(IDirect3DDevice9 *device) { mDevice = device; } + + angle::Result create(d3d::Context *context, + const DWORD *function, + size_t length, + ShaderObject **outShaderObject) + { + std::lock_guard<std::mutex> lock(mMutex); + + std::string key(reinterpret_cast<const char *>(function), length); + typename Map::iterator it = mMap.find(key); + if (it != mMap.end()) + { + it->second->AddRef(); + *outShaderObject = it->second; + return angle::Result::Continue; + } + + ShaderObject *shader; + HRESULT result = createShader(function, &shader); + ANGLE_TRY_HR(context, result, "Failed to create shader"); + + // Random eviction policy. + if (mMap.size() >= kMaxMapSize) + { + SafeRelease(mMap.begin()->second); + mMap.erase(mMap.begin()); + } + + shader->AddRef(); + mMap[key] = shader; + + *outShaderObject = shader; + return angle::Result::Continue; + } + + void clear() + { + std::lock_guard<std::mutex> lock(mMutex); + + for (typename Map::iterator it = mMap.begin(); it != mMap.end(); ++it) + { + SafeRelease(it->second); + } + + mMap.clear(); + } + + private: + const static size_t kMaxMapSize = 100; + + HRESULT createShader(const DWORD *function, IDirect3DVertexShader9 **shader) + { + return mDevice->CreateVertexShader(function, shader); + } + + HRESULT createShader(const DWORD *function, IDirect3DPixelShader9 **shader) + { + return mDevice->CreatePixelShader(function, shader); + } + + typedef angle::HashMap<std::string, ShaderObject *> Map; + Map mMap; + std::mutex mMutex; + + IDirect3DDevice9 *mDevice; +}; + +typedef ShaderCache<IDirect3DVertexShader9> VertexShaderCache; +typedef ShaderCache<IDirect3DPixelShader9> PixelShaderCache; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_SHADERCACHE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.cpp new file mode 100644 index 0000000000..b5c237f9a7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.cpp @@ -0,0 +1,51 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable9.cpp: Implements a D3D9-specific class to contain shader +// executable implementation details. + +#include "libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h" + +#include "common/debug.h" + +namespace rx +{ + +ShaderExecutable9::ShaderExecutable9(const void *function, + size_t length, + IDirect3DPixelShader9 *executable) + : ShaderExecutableD3D(function, length) +{ + mPixelExecutable = executable; + mVertexExecutable = nullptr; +} + +ShaderExecutable9::ShaderExecutable9(const void *function, + size_t length, + IDirect3DVertexShader9 *executable) + : ShaderExecutableD3D(function, length) +{ + mVertexExecutable = executable; + mPixelExecutable = nullptr; +} + +ShaderExecutable9::~ShaderExecutable9() +{ + SafeRelease(mVertexExecutable); + SafeRelease(mPixelExecutable); +} + +IDirect3DVertexShader9 *ShaderExecutable9::getVertexShader() const +{ + return mVertexExecutable; +} + +IDirect3DPixelShader9 *ShaderExecutable9::getPixelShader() const +{ + return mPixelExecutable; +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h new file mode 100644 index 0000000000..0c8c595ef0 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/ShaderExecutable9.h @@ -0,0 +1,35 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// ShaderExecutable9.h: Defines a D3D9-specific class to contain shader +// executable implementation details. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_SHADEREXECUTABLE9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_SHADEREXECUTABLE9_H_ + +#include "libANGLE/renderer/d3d/ShaderExecutableD3D.h" + +namespace rx +{ + +class ShaderExecutable9 : public ShaderExecutableD3D +{ + public: + ShaderExecutable9(const void *function, size_t length, IDirect3DPixelShader9 *executable); + ShaderExecutable9(const void *function, size_t length, IDirect3DVertexShader9 *executable); + ~ShaderExecutable9() override; + + IDirect3DPixelShader9 *getPixelShader() const; + IDirect3DVertexShader9 *getVertexShader() const; + + private: + IDirect3DPixelShader9 *mPixelExecutable; + IDirect3DVertexShader9 *mVertexExecutable; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_SHADEREXECUTABLE9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.cpp new file mode 100644 index 0000000000..cad011b25a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.cpp @@ -0,0 +1,888 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StateManager9.cpp: Defines a class for caching D3D9 state +#include "libANGLE/renderer/d3d/d3d9/StateManager9.h" + +#include "common/bitset_utils.h" +#include "common/utilities.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ + +StateManager9::StateManager9(Renderer9 *renderer9) + : mUsingZeroColorMaskWorkaround(false), + mCurSampleAlphaToCoverage(false), + mCurBlendState(), + mCurBlendColor(0, 0, 0, 0), + mCurSampleMask(0), + mCurRasterState(), + mCurDepthSize(0), + mCurDepthStencilState(), + mCurStencilRef(0), + mCurStencilBackRef(0), + mCurFrontFaceCCW(0), + mCurStencilSize(0), + mCurScissorRect(), + mCurScissorEnabled(false), + mCurViewport(), + mCurNear(0.0f), + mCurFar(0.0f), + mCurDepthFront(0.0f), + mCurIgnoreViewport(false), + mRenderer9(renderer9), + mDirtyBits() +{ + mBlendStateDirtyBits.set(DIRTY_BIT_BLEND_ENABLED); + mBlendStateDirtyBits.set(DIRTY_BIT_BLEND_COLOR); + mBlendStateDirtyBits.set(DIRTY_BIT_BLEND_FUNCS_EQUATIONS); + mBlendStateDirtyBits.set(DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE); + mBlendStateDirtyBits.set(DIRTY_BIT_COLOR_MASK); + mBlendStateDirtyBits.set(DIRTY_BIT_DITHER); + mBlendStateDirtyBits.set(DIRTY_BIT_SAMPLE_MASK); + + mRasterizerStateDirtyBits.set(DIRTY_BIT_CULL_MODE); + mRasterizerStateDirtyBits.set(DIRTY_BIT_DEPTH_BIAS); + + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_MASK); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT); + mDepthStencilStateDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK); + + mScissorStateDirtyBits.set(DIRTY_BIT_SCISSOR_ENABLED); + mScissorStateDirtyBits.set(DIRTY_BIT_SCISSOR_RECT); +} + +StateManager9::~StateManager9() {} + +void StateManager9::initialize() +{ + mUsingZeroColorMaskWorkaround = IsAMD(mRenderer9->getVendorId()); +} + +void StateManager9::forceSetBlendState() +{ + mDirtyBits |= mBlendStateDirtyBits; +} + +void StateManager9::forceSetRasterState() +{ + mDirtyBits |= mRasterizerStateDirtyBits; +} + +void StateManager9::forceSetDepthStencilState() +{ + mDirtyBits |= mDepthStencilStateDirtyBits; +} + +void StateManager9::forceSetScissorState() +{ + mDirtyBits |= mScissorStateDirtyBits; +} + +void StateManager9::forceSetViewportState() +{ + mForceSetViewport = true; +} + +void StateManager9::forceSetDXUniformsState() +{ + mDxUniformsDirty = true; +} + +void StateManager9::updateStencilSizeIfChanged(bool depthStencilInitialized, + unsigned int stencilSize) +{ + if (!depthStencilInitialized || stencilSize != mCurStencilSize) + { + mCurStencilSize = stencilSize; + forceSetDepthStencilState(); + } +} + +void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) +{ + if (!dirtyBits.any()) + { + return; + } + + for (auto dirtyBit : dirtyBits) + { + switch (dirtyBit) + { + case gl::State::DIRTY_BIT_BLEND_ENABLED: + if (state.getBlendState().blend != mCurBlendState.blend) + { + mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED); + // BlendColor and funcs and equations has to be set if blend is enabled + mDirtyBits.set(DIRTY_BIT_BLEND_COLOR); + mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS_EQUATIONS); + + // The color mask may have to be updated if the blend state changes + if (mUsingZeroColorMaskWorkaround) + { + mDirtyBits.set(DIRTY_BIT_COLOR_MASK); + } + } + break; + case gl::State::DIRTY_BIT_BLEND_FUNCS: + { + const gl::BlendState &blendState = state.getBlendState(); + if (blendState.sourceBlendRGB != mCurBlendState.sourceBlendRGB || + blendState.destBlendRGB != mCurBlendState.destBlendRGB || + blendState.sourceBlendAlpha != mCurBlendState.sourceBlendAlpha || + blendState.destBlendAlpha != mCurBlendState.destBlendAlpha) + { + mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS_EQUATIONS); + // BlendColor depends on the values of blend funcs + mDirtyBits.set(DIRTY_BIT_BLEND_COLOR); + + // The color mask may have to be updated if the blend funcs change + if (mUsingZeroColorMaskWorkaround) + { + mDirtyBits.set(DIRTY_BIT_COLOR_MASK); + } + } + break; + } + case gl::State::DIRTY_BIT_BLEND_EQUATIONS: + { + const gl::BlendState &blendState = state.getBlendState(); + if (blendState.blendEquationRGB != mCurBlendState.blendEquationRGB || + blendState.blendEquationAlpha != mCurBlendState.blendEquationAlpha) + { + mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS_EQUATIONS); + + // The color mask may have to be updated if the blend funcs change + if (mUsingZeroColorMaskWorkaround) + { + mDirtyBits.set(DIRTY_BIT_COLOR_MASK); + } + } + break; + } + case gl::State::DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED: + if (state.isSampleAlphaToCoverageEnabled() != mCurSampleAlphaToCoverage) + { + mDirtyBits.set(DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE); + } + break; + case gl::State::DIRTY_BIT_COLOR_MASK: + { + const gl::BlendState &blendState = state.getBlendState(); + if (blendState.colorMaskRed != mCurBlendState.colorMaskRed || + blendState.colorMaskGreen != mCurBlendState.colorMaskGreen || + blendState.colorMaskBlue != mCurBlendState.colorMaskBlue || + blendState.colorMaskAlpha != mCurBlendState.colorMaskAlpha) + { + mDirtyBits.set(DIRTY_BIT_COLOR_MASK); + + // The color mask can cause the blend state to get out of sync when using the + // zero color mask workaround + if (mUsingZeroColorMaskWorkaround) + { + mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED); + mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS_EQUATIONS); + } + } + break; + } + case gl::State::DIRTY_BIT_DITHER_ENABLED: + if (state.getRasterizerState().dither != mCurRasterState.dither) + { + mDirtyBits.set(DIRTY_BIT_DITHER); + } + break; + case gl::State::DIRTY_BIT_BLEND_COLOR: + if (state.getBlendColor() != mCurBlendColor) + { + mDirtyBits.set(DIRTY_BIT_BLEND_COLOR); + } + break; + case gl::State::DIRTY_BIT_CULL_FACE_ENABLED: + if (state.getRasterizerState().cullFace != mCurRasterState.cullFace) + { + mDirtyBits.set(DIRTY_BIT_CULL_MODE); + } + break; + case gl::State::DIRTY_BIT_CULL_FACE: + if (state.getRasterizerState().cullMode != mCurRasterState.cullMode) + { + mDirtyBits.set(DIRTY_BIT_CULL_MODE); + } + break; + case gl::State::DIRTY_BIT_FRONT_FACE: + if (state.getRasterizerState().frontFace != mCurRasterState.frontFace) + { + mDirtyBits.set(DIRTY_BIT_CULL_MODE); + + // Viewport state depends on rasterizer.frontface + mDirtyBits.set(DIRTY_BIT_VIEWPORT); + } + break; + case gl::State::DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED: + if (state.getRasterizerState().polygonOffsetFill != + mCurRasterState.polygonOffsetFill) + { + mDirtyBits.set(DIRTY_BIT_DEPTH_BIAS); + } + break; + case gl::State::DIRTY_BIT_POLYGON_OFFSET: + { + const gl::RasterizerState &rasterizerState = state.getRasterizerState(); + if (rasterizerState.polygonOffsetFactor != mCurRasterState.polygonOffsetFactor || + rasterizerState.polygonOffsetUnits != mCurRasterState.polygonOffsetUnits) + { + mDirtyBits.set(DIRTY_BIT_DEPTH_BIAS); + } + break; + } + // Depth and stencil redundant state changes are guarded in the + // frontend so for related cases here just set the dirty bit. + case gl::State::DIRTY_BIT_DEPTH_MASK: + if (state.getDepthStencilState().depthMask != mCurDepthStencilState.depthMask) + { + mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_MASK); + } + break; + case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED: + mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC); + break; + case gl::State::DIRTY_BIT_DEPTH_FUNC: + mDirtyBits.set(DIRTY_BIT_STENCIL_DEPTH_FUNC); + break; + case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED: + mDirtyBits.set(DIRTY_BIT_STENCIL_TEST_ENABLED); + // If we enable the stencil test, all of these must be set + mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK); + mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT); + mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT); + mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK); + mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT); + mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK); + break; + case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT: + mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_FRONT); + break; + case gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK: + mDirtyBits.set(DIRTY_BIT_STENCIL_FUNCS_BACK); + break; + case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT: + mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_FRONT); + break; + case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK: + mDirtyBits.set(DIRTY_BIT_STENCIL_WRITEMASK_BACK); + break; + case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT: + mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_FRONT); + break; + case gl::State::DIRTY_BIT_STENCIL_OPS_BACK: + mDirtyBits.set(DIRTY_BIT_STENCIL_OPS_BACK); + break; + case gl::State::DIRTY_BIT_SCISSOR_TEST_ENABLED: + if (state.isScissorTestEnabled() != mCurScissorEnabled) + { + mDirtyBits.set(DIRTY_BIT_SCISSOR_ENABLED); + // If scissor is enabled, we have to set the scissor rect + mDirtyBits.set(DIRTY_BIT_SCISSOR_RECT); + } + break; + case gl::State::DIRTY_BIT_SCISSOR: + if (state.getScissor() != mCurScissorRect) + { + mDirtyBits.set(DIRTY_BIT_SCISSOR_RECT); + } + break; + case gl::State::DIRTY_BIT_DEPTH_RANGE: + mDirtyBits.set(DIRTY_BIT_VIEWPORT); + break; + case gl::State::DIRTY_BIT_VIEWPORT: + if (state.getViewport() != mCurViewport) + { + mDirtyBits.set(DIRTY_BIT_VIEWPORT); + } + break; + default: + break; + } + } +} + +void StateManager9::setBlendDepthRasterStates(const gl::State &glState, unsigned int sampleMask) +{ + const gl::Framebuffer *framebuffer = glState.getDrawFramebuffer(); + + const gl::BlendState &blendState = glState.getBlendState(); + const gl::ColorF &blendColor = glState.getBlendColor(); + const gl::RasterizerState &rasterState = glState.getRasterizerState(); + + const auto &depthStencilState = glState.getDepthStencilState(); + bool frontFaceCCW = (glState.getRasterizerState().frontFace == GL_CCW); + unsigned int maxStencil = (1 << mCurStencilSize) - 1; + + // All the depth stencil states depends on the front face ccw variable + if (frontFaceCCW != mCurFrontFaceCCW) + { + forceSetDepthStencilState(); + mCurFrontFaceCCW = frontFaceCCW; + } + + for (auto dirtyBit : mDirtyBits) + { + switch (dirtyBit) + { + case DIRTY_BIT_BLEND_ENABLED: + setBlendEnabled(blendState.blend); + break; + case DIRTY_BIT_BLEND_COLOR: + setBlendColor(blendState, blendColor); + break; + case DIRTY_BIT_BLEND_FUNCS_EQUATIONS: + setBlendFuncsEquations(blendState); + break; + case DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE: + setSampleAlphaToCoverage(glState.isSampleAlphaToCoverageEnabled()); + break; + case DIRTY_BIT_COLOR_MASK: + setColorMask(framebuffer, blendState.colorMaskRed, blendState.colorMaskBlue, + blendState.colorMaskGreen, blendState.colorMaskAlpha); + break; + case DIRTY_BIT_DITHER: + setDither(rasterState.dither); + break; + case DIRTY_BIT_CULL_MODE: + setCullMode(rasterState.cullFace, rasterState.cullMode, rasterState.frontFace); + break; + case DIRTY_BIT_DEPTH_BIAS: + setDepthBias(rasterState.polygonOffsetFill, rasterState.polygonOffsetFactor, + rasterState.polygonOffsetUnits); + break; + case DIRTY_BIT_STENCIL_DEPTH_MASK: + setDepthMask(depthStencilState.depthMask); + break; + case DIRTY_BIT_STENCIL_DEPTH_FUNC: + setDepthFunc(depthStencilState.depthTest, depthStencilState.depthFunc); + break; + case DIRTY_BIT_STENCIL_TEST_ENABLED: + setStencilTestEnabled(depthStencilState.stencilTest); + break; + case DIRTY_BIT_STENCIL_FUNCS_FRONT: + setStencilFuncsFront(depthStencilState.stencilFunc, depthStencilState.stencilMask, + glState.getStencilRef(), frontFaceCCW, maxStencil); + break; + case DIRTY_BIT_STENCIL_FUNCS_BACK: + setStencilFuncsBack(depthStencilState.stencilBackFunc, + depthStencilState.stencilBackMask, glState.getStencilBackRef(), + frontFaceCCW, maxStencil); + break; + case DIRTY_BIT_STENCIL_WRITEMASK_FRONT: + setStencilWriteMask(depthStencilState.stencilWritemask, frontFaceCCW); + break; + case DIRTY_BIT_STENCIL_WRITEMASK_BACK: + setStencilBackWriteMask(depthStencilState.stencilBackWritemask, frontFaceCCW); + break; + case DIRTY_BIT_STENCIL_OPS_FRONT: + setStencilOpsFront(depthStencilState.stencilFail, + depthStencilState.stencilPassDepthFail, + depthStencilState.stencilPassDepthPass, frontFaceCCW); + break; + case DIRTY_BIT_STENCIL_OPS_BACK: + setStencilOpsBack(depthStencilState.stencilBackFail, + depthStencilState.stencilBackPassDepthFail, + depthStencilState.stencilBackPassDepthPass, frontFaceCCW); + break; + default: + break; + } + } + + if (sampleMask != mCurSampleMask) + { + setSampleMask(sampleMask); + } +} + +void StateManager9::setViewportState(const gl::Rectangle &viewport, + float zNear, + float zFar, + gl::PrimitiveMode drawMode, + GLenum frontFace, + bool ignoreViewport) +{ + if (!mDirtyBits.test(DIRTY_BIT_VIEWPORT) && mCurIgnoreViewport == ignoreViewport) + return; + + gl::Rectangle actualViewport = viewport; + float actualZNear = gl::clamp01(zNear); + float actualZFar = gl::clamp01(zFar); + + if (ignoreViewport) + { + actualViewport.x = 0; + actualViewport.y = 0; + actualViewport.width = static_cast<int>(mRenderTargetBounds.width); + actualViewport.height = static_cast<int>(mRenderTargetBounds.height); + actualZNear = 0.0f; + actualZFar = 1.0f; + } + + D3DVIEWPORT9 dxViewport; + dxViewport.X = gl::clamp(actualViewport.x, 0, static_cast<int>(mRenderTargetBounds.width)); + dxViewport.Y = gl::clamp(actualViewport.y, 0, static_cast<int>(mRenderTargetBounds.height)); + dxViewport.Width = + gl::clamp(actualViewport.width, 0, + static_cast<int>(mRenderTargetBounds.width) - static_cast<int>(dxViewport.X)); + dxViewport.Height = + gl::clamp(actualViewport.height, 0, + static_cast<int>(mRenderTargetBounds.height) - static_cast<int>(dxViewport.Y)); + dxViewport.MinZ = actualZNear; + dxViewport.MaxZ = actualZFar; + + float depthFront = !gl::IsTriangleMode(drawMode) ? 0.0f : (frontFace == GL_CCW ? 1.0f : -1.0f); + + mRenderer9->getDevice()->SetViewport(&dxViewport); + + mCurViewport = actualViewport; + mCurNear = actualZNear; + mCurFar = actualZFar; + mCurDepthFront = depthFront; + mCurIgnoreViewport = ignoreViewport; + + // Setting shader constants + dx_VertexConstants9 vc = {}; + dx_PixelConstants9 pc = {}; + + vc.viewAdjust[0] = + static_cast<float>((actualViewport.width - static_cast<int>(dxViewport.Width)) + + 2 * (actualViewport.x - static_cast<int>(dxViewport.X)) - 1) / + dxViewport.Width; + vc.viewAdjust[1] = + static_cast<float>((actualViewport.height - static_cast<int>(dxViewport.Height)) + + 2 * (actualViewport.y - static_cast<int>(dxViewport.Y)) - 1) / + dxViewport.Height; + vc.viewAdjust[2] = static_cast<float>(actualViewport.width) / dxViewport.Width; + vc.viewAdjust[3] = static_cast<float>(actualViewport.height) / dxViewport.Height; + + pc.viewCoords[0] = actualViewport.width * 0.5f; + pc.viewCoords[1] = actualViewport.height * 0.5f; + pc.viewCoords[2] = actualViewport.x + (actualViewport.width * 0.5f); + pc.viewCoords[3] = actualViewport.y + (actualViewport.height * 0.5f); + + pc.depthFront[0] = (actualZFar - actualZNear) * 0.5f; + pc.depthFront[1] = (actualZNear + actualZFar) * 0.5f; + pc.depthFront[2] = depthFront; + + vc.depthRange[0] = actualZNear; + vc.depthRange[1] = actualZFar; + vc.depthRange[2] = actualZFar - actualZNear; + + pc.depthRange[0] = actualZNear; + pc.depthRange[1] = actualZFar; + pc.depthRange[2] = actualZFar - actualZNear; + + if (memcmp(&vc, &mVertexConstants, sizeof(dx_VertexConstants9)) != 0) + { + mVertexConstants = vc; + mDxUniformsDirty = true; + } + + if (memcmp(&pc, &mPixelConstants, sizeof(dx_PixelConstants9)) != 0) + { + mPixelConstants = pc; + mDxUniformsDirty = true; + } + + mForceSetViewport = false; +} + +void StateManager9::setShaderConstants() +{ + if (!mDxUniformsDirty) + return; + + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetVertexShaderConstantF(0, reinterpret_cast<float *>(&mVertexConstants), + sizeof(dx_VertexConstants9) / sizeof(float[4])); + device->SetPixelShaderConstantF(0, reinterpret_cast<float *>(&mPixelConstants), + sizeof(dx_PixelConstants9) / sizeof(float[4])); + mDxUniformsDirty = false; +} + +// This is separate from the main state loop because other functions +// outside call only setScissorState to update scissor state +void StateManager9::setScissorState(const gl::Rectangle &scissor, bool enabled) +{ + if (mDirtyBits.test(DIRTY_BIT_SCISSOR_ENABLED)) + setScissorEnabled(enabled); + + if (mDirtyBits.test(DIRTY_BIT_SCISSOR_RECT)) + setScissorRect(scissor, enabled); +} + +void StateManager9::setRenderTargetBounds(size_t width, size_t height) +{ + mRenderTargetBounds.width = (int)width; + mRenderTargetBounds.height = (int)height; + forceSetViewportState(); +} + +void StateManager9::setScissorEnabled(bool scissorEnabled) +{ + mRenderer9->getDevice()->SetRenderState(D3DRS_SCISSORTESTENABLE, scissorEnabled ? TRUE : FALSE); + mCurScissorEnabled = scissorEnabled; +} + +void StateManager9::setScissorRect(const gl::Rectangle &scissor, bool enabled) +{ + if (!enabled) + return; + + RECT rect; + rect.left = gl::clamp(scissor.x, 0, static_cast<int>(mRenderTargetBounds.width)); + rect.top = gl::clamp(scissor.y, 0, static_cast<int>(mRenderTargetBounds.height)); + rect.right = + gl::clamp(scissor.x + scissor.width, 0, static_cast<int>(mRenderTargetBounds.width)); + rect.bottom = + gl::clamp(scissor.y + scissor.height, 0, static_cast<int>(mRenderTargetBounds.height)); + mRenderer9->getDevice()->SetScissorRect(&rect); +} + +void StateManager9::setDepthFunc(bool depthTest, GLenum depthFunc) +{ + if (depthTest) + { + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + device->SetRenderState(D3DRS_ZFUNC, gl_d3d9::ConvertComparison(depthFunc)); + } + else + { + mRenderer9->getDevice()->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + } + + mCurDepthStencilState.depthTest = depthTest; + mCurDepthStencilState.depthFunc = depthFunc; +} + +void StateManager9::setStencilOpsFront(GLenum stencilFail, + GLenum stencilPassDepthFail, + GLenum stencilPassDepthPass, + bool frontFaceCCW) +{ + // TODO(dianx) It may be slightly more efficient todo these and other similar areas + // with separate dirty bits. + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL, + gl_d3d9::ConvertStencilOp(stencilFail)); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL, + gl_d3d9::ConvertStencilOp(stencilPassDepthFail)); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS, + gl_d3d9::ConvertStencilOp(stencilPassDepthPass)); + + mCurDepthStencilState.stencilFail = stencilFail; + mCurDepthStencilState.stencilPassDepthFail = stencilPassDepthFail; + mCurDepthStencilState.stencilPassDepthPass = stencilPassDepthPass; +} + +void StateManager9::setStencilOpsBack(GLenum stencilBackFail, + GLenum stencilBackPassDepthFail, + GLenum stencilBackPassDepthPass, + bool frontFaceCCW) +{ + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL, + gl_d3d9::ConvertStencilOp(stencilBackFail)); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL, + gl_d3d9::ConvertStencilOp(stencilBackPassDepthFail)); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS, + gl_d3d9::ConvertStencilOp(stencilBackPassDepthPass)); + + mCurDepthStencilState.stencilBackFail = stencilBackFail; + mCurDepthStencilState.stencilBackPassDepthFail = stencilBackPassDepthFail; + mCurDepthStencilState.stencilBackPassDepthPass = stencilBackPassDepthPass; +} + +void StateManager9::setStencilBackWriteMask(GLuint stencilBackWriteMask, bool frontFaceCCW) +{ + mRenderer9->getDevice()->SetRenderState( + !frontFaceCCW ? D3DRS_STENCILWRITEMASK : D3DRS_CCW_STENCILWRITEMASK, stencilBackWriteMask); + + mCurDepthStencilState.stencilBackWritemask = stencilBackWriteMask; +} + +void StateManager9::setStencilFuncsBack(GLenum stencilBackFunc, + GLuint stencilBackMask, + GLint stencilBackRef, + bool frontFaceCCW, + unsigned int maxStencil) +{ + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILFUNC : D3DRS_CCW_STENCILFUNC, + gl_d3d9::ConvertComparison(stencilBackFunc)); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILREF : D3DRS_CCW_STENCILREF, + (stencilBackRef < (int)maxStencil) ? stencilBackRef : maxStencil); + device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILMASK : D3DRS_CCW_STENCILMASK, + stencilBackMask); + + mCurDepthStencilState.stencilBackFunc = stencilBackFunc; + mCurStencilBackRef = stencilBackRef; + mCurDepthStencilState.stencilBackMask = stencilBackMask; +} + +void StateManager9::setStencilWriteMask(GLuint stencilWriteMask, bool frontFaceCCW) +{ + mRenderer9->getDevice()->SetRenderState( + frontFaceCCW ? D3DRS_STENCILWRITEMASK : D3DRS_CCW_STENCILWRITEMASK, stencilWriteMask); + mCurDepthStencilState.stencilWritemask = stencilWriteMask; +} + +void StateManager9::setStencilFuncsFront(GLenum stencilFunc, + GLuint stencilMask, + GLint stencilRef, + bool frontFaceCCW, + unsigned int maxStencil) +{ + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILFUNC : D3DRS_CCW_STENCILFUNC, + gl_d3d9::ConvertComparison(stencilFunc)); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILREF : D3DRS_CCW_STENCILREF, + (stencilRef < static_cast<int>(maxStencil)) ? stencilRef : maxStencil); + device->SetRenderState(frontFaceCCW ? D3DRS_STENCILMASK : D3DRS_CCW_STENCILMASK, stencilMask); + + mCurDepthStencilState.stencilFunc = stencilFunc; + mCurStencilRef = stencilRef; + mCurDepthStencilState.stencilMask = stencilMask; +} +void StateManager9::setStencilTestEnabled(bool stencilTestEnabled) +{ + if (stencilTestEnabled && mCurStencilSize > 0) + { + mRenderer9->getDevice()->SetRenderState(D3DRS_STENCILENABLE, TRUE); + mRenderer9->getDevice()->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, TRUE); + } + else + { + mRenderer9->getDevice()->SetRenderState(D3DRS_STENCILENABLE, FALSE); + } + + mCurDepthStencilState.stencilTest = stencilTestEnabled; +} + +void StateManager9::setDepthMask(bool depthMask) +{ + mRenderer9->getDevice()->SetRenderState(D3DRS_ZWRITEENABLE, depthMask ? TRUE : FALSE); + mCurDepthStencilState.depthMask = depthMask; +} + +// TODO(dianx) one bit for sampleAlphaToCoverage +void StateManager9::setSampleAlphaToCoverage(bool enabled) +{ + if (enabled) + { + // D3D9 support for alpha-to-coverage is vendor-specific. + UNIMPLEMENTED(); + } +} + +void StateManager9::setBlendColor(const gl::BlendState &blendState, const gl::ColorF &blendColor) +{ + if (!blendState.blend) + return; + + if (blendState.sourceBlendRGB != GL_CONSTANT_ALPHA && + blendState.sourceBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA && + blendState.destBlendRGB != GL_CONSTANT_ALPHA && + blendState.destBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA) + { + mRenderer9->getDevice()->SetRenderState(D3DRS_BLENDFACTOR, + gl_d3d9::ConvertColor(blendColor)); + } + else + { + mRenderer9->getDevice()->SetRenderState( + D3DRS_BLENDFACTOR, + D3DCOLOR_RGBA(gl::unorm<8>(blendColor.alpha), gl::unorm<8>(blendColor.alpha), + gl::unorm<8>(blendColor.alpha), gl::unorm<8>(blendColor.alpha))); + } + mCurBlendColor = blendColor; +} + +void StateManager9::setBlendFuncsEquations(const gl::BlendState &blendState) +{ + if (!blendState.blend) + return; + + IDirect3DDevice9 *device = mRenderer9->getDevice(); + + device->SetRenderState(D3DRS_SRCBLEND, gl_d3d9::ConvertBlendFunc(blendState.sourceBlendRGB)); + device->SetRenderState(D3DRS_DESTBLEND, gl_d3d9::ConvertBlendFunc(blendState.destBlendRGB)); + device->SetRenderState(D3DRS_BLENDOP, gl_d3d9::ConvertBlendOp(blendState.blendEquationRGB)); + + if (blendState.sourceBlendRGB != blendState.sourceBlendAlpha || + blendState.destBlendRGB != blendState.destBlendAlpha || + blendState.blendEquationRGB != blendState.blendEquationAlpha) + { + device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE); + + device->SetRenderState(D3DRS_SRCBLENDALPHA, + gl_d3d9::ConvertBlendFunc(blendState.sourceBlendAlpha)); + device->SetRenderState(D3DRS_DESTBLENDALPHA, + gl_d3d9::ConvertBlendFunc(blendState.destBlendAlpha)); + device->SetRenderState(D3DRS_BLENDOPALPHA, + gl_d3d9::ConvertBlendOp(blendState.blendEquationAlpha)); + } + else + { + device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE); + } + + mCurBlendState.sourceBlendRGB = blendState.sourceBlendRGB; + mCurBlendState.destBlendRGB = blendState.destBlendRGB; + mCurBlendState.blendEquationRGB = blendState.blendEquationRGB; + mCurBlendState.blendEquationAlpha = blendState.blendEquationAlpha; +} + +void StateManager9::setBlendEnabled(bool enabled) +{ + mRenderer9->getDevice()->SetRenderState(D3DRS_ALPHABLENDENABLE, enabled ? TRUE : FALSE); + mCurBlendState.blend = enabled; +} + +void StateManager9::setDither(bool dither) +{ + mRenderer9->getDevice()->SetRenderState(D3DRS_DITHERENABLE, dither ? TRUE : FALSE); + mCurRasterState.dither = dither; +} + +// TODO(dianx) one bit for color mask +void StateManager9::setColorMask(const gl::Framebuffer *framebuffer, + bool red, + bool blue, + bool green, + bool alpha) +{ + // Set the color mask + + const auto *attachment = framebuffer->getFirstColorAttachment(); + const auto &format = attachment ? attachment->getFormat() : gl::Format::Invalid(); + + DWORD colorMask = gl_d3d9::ConvertColorMask( + format.info->redBits > 0 && red, format.info->greenBits > 0 && green, + format.info->blueBits > 0 && blue, format.info->alphaBits > 0 && alpha); + + // Apparently some ATI cards have a bug where a draw with a zero color write mask can cause + // later draws to have incorrect results. Instead, set a nonzero color write mask but modify the + // blend state so that no drawing is done. + // http://anglebug.com/169 + if (colorMask == 0 && mUsingZeroColorMaskWorkaround) + { + IDirect3DDevice9 *device = mRenderer9->getDevice(); + // Enable green channel, but set blending so nothing will be drawn. + device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_GREEN); + + device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + + device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO); + device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); + device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); + + mCurBlendState.colorMaskRed = false; + mCurBlendState.colorMaskGreen = true; + mCurBlendState.colorMaskBlue = false; + mCurBlendState.colorMaskAlpha = false; + + mCurBlendState.blend = true; + mCurBlendState.sourceBlendRGB = GL_ZERO; + mCurBlendState.sourceBlendAlpha = GL_ZERO; + mCurBlendState.destBlendRGB = GL_ONE; + mCurBlendState.destBlendAlpha = GL_ONE; + mCurBlendState.blendEquationRGB = GL_FUNC_ADD; + mCurBlendState.blendEquationAlpha = GL_FUNC_ADD; + } + else + { + mRenderer9->getDevice()->SetRenderState(D3DRS_COLORWRITEENABLE, colorMask); + + mCurBlendState.colorMaskRed = red; + mCurBlendState.colorMaskGreen = green; + mCurBlendState.colorMaskBlue = blue; + mCurBlendState.colorMaskAlpha = alpha; + } +} + +void StateManager9::setSampleMask(unsigned int sampleMask) +{ + IDirect3DDevice9 *device = mRenderer9->getDevice(); + // Set the multisample mask + device->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE); + device->SetRenderState(D3DRS_MULTISAMPLEMASK, static_cast<DWORD>(sampleMask)); + + mCurSampleMask = sampleMask; +} + +void StateManager9::setCullMode(bool cullFace, gl::CullFaceMode cullMode, GLenum frontFace) +{ + if (cullFace) + { + mRenderer9->getDevice()->SetRenderState(D3DRS_CULLMODE, + gl_d3d9::ConvertCullMode(cullMode, frontFace)); + } + else + { + mRenderer9->getDevice()->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + } + + mCurRasterState.cullFace = cullFace; + mCurRasterState.cullMode = cullMode; + mCurRasterState.frontFace = frontFace; +} + +void StateManager9::setDepthBias(bool polygonOffsetFill, + GLfloat polygonOffsetFactor, + GLfloat polygonOffsetUnits) +{ + if (polygonOffsetFill) + { + if (mCurDepthSize > 0) + { + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, *(DWORD *)&polygonOffsetFactor); + + float depthBias = ldexp(polygonOffsetUnits, -static_cast<int>(mCurDepthSize)); + device->SetRenderState(D3DRS_DEPTHBIAS, *(DWORD *)&depthBias); + } + } + else + { + IDirect3DDevice9 *device = mRenderer9->getDevice(); + device->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0); + device->SetRenderState(D3DRS_DEPTHBIAS, 0); + } + + mCurRasterState.polygonOffsetFill = polygonOffsetFill; + mCurRasterState.polygonOffsetFactor = polygonOffsetFactor; + mCurRasterState.polygonOffsetUnits = polygonOffsetUnits; +} + +void StateManager9::updateDepthSizeIfChanged(bool depthStencilInitialized, unsigned int depthSize) +{ + if (!depthStencilInitialized || depthSize != mCurDepthSize) + { + mCurDepthSize = depthSize; + forceSetRasterState(); + } +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.h new file mode 100644 index 0000000000..b047b69cdd --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/StateManager9.h @@ -0,0 +1,211 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// StateManager9.h: Defines a class for caching D3D9 state + +#ifndef LIBANGLE_RENDERER_D3D9_STATEMANAGER9_H_ +#define LIBANGLE_RENDERER_D3D9_STATEMANAGER9_H_ + +#include "libANGLE/State.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/renderer/d3d/RendererD3D.h" + +namespace rx +{ + +class Renderer9; + +struct dx_VertexConstants9 +{ + float depthRange[4]; + float viewAdjust[4]; + float viewCoords[4]; +}; + +struct dx_PixelConstants9 +{ + float depthRange[4]; + float viewCoords[4]; + float depthFront[4]; +}; + +class StateManager9 final : angle::NonCopyable +{ + public: + StateManager9(Renderer9 *renderer9); + ~StateManager9(); + + void initialize(); + + void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits); + + void setBlendDepthRasterStates(const gl::State &glState, unsigned int sampleMask); + void setScissorState(const gl::Rectangle &scissor, bool enabled); + void setViewportState(const gl::Rectangle &viewport, + float zNear, + float zFar, + gl::PrimitiveMode drawMode, + GLenum frontFace, + bool ignoreViewport); + + void setShaderConstants(); + + void forceSetBlendState(); + void forceSetRasterState(); + void forceSetDepthStencilState(); + void forceSetScissorState(); + void forceSetViewportState(); + void forceSetDXUniformsState(); + + void updateDepthSizeIfChanged(bool depthStencilInitialized, unsigned int depthSize); + void updateStencilSizeIfChanged(bool depthStencilInitialized, unsigned int stencilSize); + + void setRenderTargetBounds(size_t width, size_t height); + + int getRenderTargetWidth() const { return mRenderTargetBounds.width; } + int getRenderTargetHeight() const { return mRenderTargetBounds.height; } + + void setAllDirtyBits() { mDirtyBits.set(); } + void resetDirtyBits() { mDirtyBits.reset(); } + + private: + // Blend state functions + void setBlendEnabled(bool enabled); + void setBlendColor(const gl::BlendState &blendState, const gl::ColorF &blendColor); + void setBlendFuncsEquations(const gl::BlendState &blendState); + void setColorMask(const gl::Framebuffer *framebuffer, + bool red, + bool blue, + bool green, + bool alpha); + void setSampleAlphaToCoverage(bool enabled); + void setDither(bool dither); + void setSampleMask(unsigned int sampleMask); + + // Current raster state functions + void setCullMode(bool cullFace, gl::CullFaceMode cullMode, GLenum frontFace); + void setDepthBias(bool polygonOffsetFill, + GLfloat polygonOffsetFactor, + GLfloat polygonOffsetUnits); + + // Depth stencil state functions + void setStencilOpsFront(GLenum stencilFail, + GLenum stencilPassDepthFail, + GLenum stencilPassDepthPass, + bool frontFaceCCW); + void setStencilOpsBack(GLenum stencilBackFail, + GLenum stencilBackPassDepthFail, + GLenum stencilBackPassDepthPass, + bool frontFaceCCW); + void setStencilBackWriteMask(GLuint stencilBackWriteMask, bool frontFaceCCW); + void setDepthFunc(bool depthTest, GLenum depthFunc); + void setStencilTestEnabled(bool enabled); + void setDepthMask(bool depthMask); + void setStencilFuncsFront(GLenum stencilFunc, + GLuint stencilMask, + GLint stencilRef, + bool frontFaceCCW, + unsigned int maxStencil); + void setStencilFuncsBack(GLenum stencilBackFunc, + GLuint stencilBackMask, + GLint stencilBackRef, + bool frontFaceCCW, + unsigned int maxStencil); + void setStencilWriteMask(GLuint stencilWriteMask, bool frontFaceCCW); + + void setScissorEnabled(bool scissorEnabled); + void setScissorRect(const gl::Rectangle &scissor, bool enabled); + + enum DirtyBitType + { + // Blend dirty bits + DIRTY_BIT_BLEND_ENABLED, + DIRTY_BIT_BLEND_COLOR, + DIRTY_BIT_BLEND_FUNCS_EQUATIONS, + DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE, + DIRTY_BIT_COLOR_MASK, + DIRTY_BIT_DITHER, + DIRTY_BIT_SAMPLE_MASK, + + // Rasterizer dirty bits + DIRTY_BIT_CULL_MODE, + DIRTY_BIT_DEPTH_BIAS, + + // Depth stencil dirty bits + DIRTY_BIT_STENCIL_DEPTH_MASK, + DIRTY_BIT_STENCIL_DEPTH_FUNC, + DIRTY_BIT_STENCIL_TEST_ENABLED, + DIRTY_BIT_STENCIL_FUNCS_FRONT, + DIRTY_BIT_STENCIL_FUNCS_BACK, + DIRTY_BIT_STENCIL_WRITEMASK_FRONT, + DIRTY_BIT_STENCIL_WRITEMASK_BACK, + DIRTY_BIT_STENCIL_OPS_FRONT, + DIRTY_BIT_STENCIL_OPS_BACK, + + // Scissor dirty bits + DIRTY_BIT_SCISSOR_ENABLED, + DIRTY_BIT_SCISSOR_RECT, + + // Viewport dirty bits + DIRTY_BIT_VIEWPORT, + + DIRTY_BIT_MAX + }; + + using DirtyBits = angle::BitSet<DIRTY_BIT_MAX>; + + bool mUsingZeroColorMaskWorkaround; + + bool mCurSampleAlphaToCoverage; + + // Currently applied blend state + gl::BlendState mCurBlendState; + gl::ColorF mCurBlendColor; + unsigned int mCurSampleMask; + DirtyBits mBlendStateDirtyBits; + + // Currently applied raster state + gl::RasterizerState mCurRasterState; + unsigned int mCurDepthSize; + DirtyBits mRasterizerStateDirtyBits; + + // Currently applied depth stencil state + gl::DepthStencilState mCurDepthStencilState; + int mCurStencilRef; + int mCurStencilBackRef; + bool mCurFrontFaceCCW; + unsigned int mCurStencilSize; + DirtyBits mDepthStencilStateDirtyBits; + + // Currently applied scissor states + gl::Rectangle mCurScissorRect; + bool mCurScissorEnabled; + gl::Extents mRenderTargetBounds; + DirtyBits mScissorStateDirtyBits; + + // Currently applied viewport states + bool mForceSetViewport; + gl::Rectangle mCurViewport; + float mCurNear; + float mCurFar; + float mCurDepthFront; + bool mCurIgnoreViewport; + + dx_VertexConstants9 mVertexConstants; + dx_PixelConstants9 mPixelConstants; + bool mDxUniformsDirty; + + // FIXME: Unsupported by D3D9 + static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILREF = D3DRS_STENCILREF; + static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILMASK = D3DRS_STENCILMASK; + static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILWRITEMASK = D3DRS_STENCILWRITEMASK; + + Renderer9 *mRenderer9; + DirtyBits mDirtyBits; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D9_STATEMANAGER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp new file mode 100644 index 0000000000..c8abac7a57 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp @@ -0,0 +1,472 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChain9.cpp: Implements a back-end specific class for the D3D9 swap chain. + +#include "libANGLE/renderer/d3d/d3d9/SwapChain9.h" + +#include "libANGLE/features.h" +#include "libANGLE/renderer/d3d/d3d9/NativeWindow9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ + +SwapChain9::SwapChain9(Renderer9 *renderer, + NativeWindow9 *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation) + : SwapChainD3D(shareHandle, d3dTexture, backBufferFormat, depthBufferFormat), + mRenderer(renderer), + mWidth(-1), + mHeight(-1), + mSwapInterval(-1), + mNativeWindow(nativeWindow), + mSwapChain(nullptr), + mBackBuffer(nullptr), + mRenderTarget(nullptr), + mDepthStencil(nullptr), + mOffscreenTexture(nullptr), + mColorRenderTarget(this, false), + mDepthStencilRenderTarget(this, true) +{ + ASSERT(orientation == 0); +} + +SwapChain9::~SwapChain9() +{ + release(); +} + +void SwapChain9::release() +{ + SafeRelease(mSwapChain); + SafeRelease(mBackBuffer); + SafeRelease(mDepthStencil); + SafeRelease(mRenderTarget); + SafeRelease(mOffscreenTexture); + + if (mNativeWindow->getNativeWindow()) + { + mShareHandle = nullptr; + } +} + +static DWORD convertInterval(EGLint interval) +{ +#if ANGLE_VSYNC == ANGLE_DISABLED + return D3DPRESENT_INTERVAL_IMMEDIATE; +#else + switch (interval) + { + case 0: + return D3DPRESENT_INTERVAL_IMMEDIATE; + case 1: + return D3DPRESENT_INTERVAL_ONE; + case 2: + return D3DPRESENT_INTERVAL_TWO; + case 3: + return D3DPRESENT_INTERVAL_THREE; + case 4: + return D3DPRESENT_INTERVAL_FOUR; + default: + UNREACHABLE(); + } + + return D3DPRESENT_INTERVAL_DEFAULT; +#endif +} + +EGLint SwapChain9::resize(DisplayD3D *displayD3D, int backbufferWidth, int backbufferHeight) +{ + // D3D9 does not support resizing swap chains without recreating them + return reset(displayD3D, backbufferWidth, backbufferHeight, mSwapInterval); +} + +EGLint SwapChain9::reset(DisplayD3D *displayD3D, + int backbufferWidth, + int backbufferHeight, + EGLint swapInterval) +{ + IDirect3DDevice9 *device = mRenderer->getDevice(); + + if (device == nullptr) + { + return EGL_BAD_ACCESS; + } + + // Evict all non-render target textures to system memory and release all resources + // before reallocating them to free up as much video memory as possible. + device->EvictManagedResources(); + + HRESULT result; + + // Release specific resources to free up memory for the new render target, while the + // old render target still exists for the purpose of preserving its contents. + SafeRelease(mSwapChain); + SafeRelease(mBackBuffer); + SafeRelease(mOffscreenTexture); + SafeRelease(mDepthStencil); + + const d3d9::TextureFormat &backBufferd3dFormatInfo = + d3d9::GetTextureFormatInfo(mOffscreenRenderTargetFormat); + if (mD3DTexture != nullptr) + { + result = mD3DTexture->QueryInterface(&mOffscreenTexture); + ASSERT(SUCCEEDED(result)); + } + else + { + HANDLE *pShareHandle = nullptr; + if (!mNativeWindow->getNativeWindow() && mRenderer->getShareHandleSupport()) + { + pShareHandle = &mShareHandle; + } + + result = device->CreateTexture(backbufferWidth, backbufferHeight, 1, D3DUSAGE_RENDERTARGET, + backBufferd3dFormatInfo.texFormat, D3DPOOL_DEFAULT, + &mOffscreenTexture, pShareHandle); + if (FAILED(result)) + { + ERR() << "Could not create offscreen texture, " << gl::FmtHR(result); + release(); + + if (d3d9::isDeviceLostError(result)) + { + return EGL_CONTEXT_LOST; + } + else + { + return EGL_BAD_ALLOC; + } + } + } + + IDirect3DSurface9 *oldRenderTarget = mRenderTarget; + + result = mOffscreenTexture->GetSurfaceLevel(0, &mRenderTarget); + ASSERT(SUCCEEDED(result)); + + if (oldRenderTarget) + { + RECT rect = {0, 0, mWidth, mHeight}; + + if (rect.right > static_cast<LONG>(backbufferWidth)) + { + rect.right = backbufferWidth; + } + + if (rect.bottom > static_cast<LONG>(backbufferHeight)) + { + rect.bottom = backbufferHeight; + } + + mRenderer->endScene(); + + result = device->StretchRect(oldRenderTarget, &rect, mRenderTarget, &rect, D3DTEXF_NONE); + ASSERT(SUCCEEDED(result)); + + SafeRelease(oldRenderTarget); + } + + const d3d9::TextureFormat &depthBufferd3dFormatInfo = + d3d9::GetTextureFormatInfo(mDepthBufferFormat); + + // Don't create a swapchain for NULLREF devices + D3DDEVTYPE deviceType = mRenderer->getD3D9DeviceType(); + EGLNativeWindowType window = mNativeWindow->getNativeWindow(); + if (window && deviceType != D3DDEVTYPE_NULLREF) + { + D3DPRESENT_PARAMETERS presentParameters = {}; + presentParameters.AutoDepthStencilFormat = depthBufferd3dFormatInfo.renderFormat; + presentParameters.BackBufferCount = 1; + presentParameters.BackBufferFormat = backBufferd3dFormatInfo.renderFormat; + presentParameters.EnableAutoDepthStencil = FALSE; + presentParameters.Flags = 0; + presentParameters.hDeviceWindow = window; + presentParameters.MultiSampleQuality = 0; // FIXME: Unimplemented + presentParameters.MultiSampleType = D3DMULTISAMPLE_NONE; // FIXME: Unimplemented + presentParameters.PresentationInterval = convertInterval(swapInterval); + presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD; + presentParameters.Windowed = TRUE; + presentParameters.BackBufferWidth = backbufferWidth; + presentParameters.BackBufferHeight = backbufferHeight; + + // http://crbug.com/140239 + // http://crbug.com/143434 + // + // Some AMD/Intel switchable systems / drivers appear to round swap chain surfaces to a + // multiple of 64 pixels in width when using the integrated Intel. This rounds the width up + // rather than down. + // + // Some non-switchable AMD GPUs / drivers do not respect the source rectangle to Present. + // Therefore, when the vendor ID is not Intel, the back buffer width must be exactly the + // same width as the window or horizontal scaling will occur. + if (IsIntel(mRenderer->getVendorId())) + { + presentParameters.BackBufferWidth = (presentParameters.BackBufferWidth + 63) / 64 * 64; + } + + result = device->CreateAdditionalSwapChain(&presentParameters, &mSwapChain); + + if (FAILED(result)) + { + ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || + result == D3DERR_INVALIDCALL || result == D3DERR_DEVICELOST); + + ERR() << "Could not create additional swap chains or offscreen surfaces, " + << gl::FmtHR(result); + release(); + + if (d3d9::isDeviceLostError(result)) + { + return EGL_CONTEXT_LOST; + } + else + { + return EGL_BAD_ALLOC; + } + } + + result = mSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mBackBuffer); + ASSERT(SUCCEEDED(result)); + InvalidateRect(window, nullptr, FALSE); + } + + if (mDepthBufferFormat != GL_NONE) + { + result = device->CreateDepthStencilSurface( + backbufferWidth, backbufferHeight, depthBufferd3dFormatInfo.renderFormat, + D3DMULTISAMPLE_NONE, 0, FALSE, &mDepthStencil, nullptr); + + if (FAILED(result)) + { + ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || + result == D3DERR_INVALIDCALL); + + ERR() << "Could not create depthstencil surface for new swap chain, " + << gl::FmtHR(result); + release(); + + if (d3d9::isDeviceLostError(result)) + { + return EGL_CONTEXT_LOST; + } + else + { + return EGL_BAD_ALLOC; + } + } + } + + mWidth = backbufferWidth; + mHeight = backbufferHeight; + mSwapInterval = swapInterval; + + return EGL_SUCCESS; +} + +// parameters should be validated/clamped by caller +EGLint SwapChain9::swapRect(DisplayD3D *displayD3D, EGLint x, EGLint y, EGLint width, EGLint height) +{ + if (!mSwapChain) + { + return EGL_SUCCESS; + } + + IDirect3DDevice9 *device = mRenderer->getDevice(); + + // Disable all pipeline operations + device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); + device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + device->SetRenderState(D3DRS_STENCILENABLE, FALSE); + device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0); + device->SetRenderState(D3DRS_COLORWRITEENABLE, + D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | + D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED); + device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE); + device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE); + device->SetPixelShader(nullptr); + device->SetVertexShader(nullptr); + + device->SetRenderTarget(0, mBackBuffer); + device->SetDepthStencilSurface(nullptr); + + device->SetTexture(0, mOffscreenTexture); + device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); + device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); + device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE); + device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); + device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); + device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); + device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); + device->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1); + + for (UINT streamIndex = 0; streamIndex < gl::MAX_VERTEX_ATTRIBS; streamIndex++) + { + device->SetStreamSourceFreq(streamIndex, 1); + } + + D3DVIEWPORT9 viewport = {0, 0, static_cast<DWORD>(mWidth), static_cast<DWORD>(mHeight), + 0.0f, 1.0f}; + device->SetViewport(&viewport); + + float x1 = x - 0.5f; + float y1 = (mHeight - y - height) - 0.5f; + float x2 = (x + width) - 0.5f; + float y2 = (mHeight - y) - 0.5f; + + float u1 = x / float(mWidth); + float v1 = y / float(mHeight); + float u2 = (x + width) / float(mWidth); + float v2 = (y + height) / float(mHeight); + + float quad[4][6] = {{x1, y1, 0.0f, 1.0f, u1, v2}, + {x2, y1, 0.0f, 1.0f, u2, v2}, + {x2, y2, 0.0f, 1.0f, u2, v1}, + {x1, y2, 0.0f, 1.0f, u1, v1}}; // x, y, z, rhw, u, v + + mRenderer->startScene(); + device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, quad, 6 * sizeof(float)); + mRenderer->endScene(); + + device->SetTexture(0, nullptr); + + RECT rect = {static_cast<LONG>(x), static_cast<LONG>(mHeight - y - height), + static_cast<LONG>(x + width), static_cast<LONG>(mHeight - y)}; + + HRESULT result = mSwapChain->Present(&rect, &rect, nullptr, nullptr, 0); + + mRenderer->markAllStateDirty(); + + if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || + result == D3DERR_DRIVERINTERNALERROR) + { + return EGL_BAD_ALLOC; + } + + // On Windows 8 systems, IDirect3DSwapChain9::Present sometimes returns 0x88760873 when the + // windows is in the process of entering/exiting fullscreen. This code doesn't seem to have any + // documentation. The device appears to be ok after emitting this error so simply return a + // failure to swap. + if (result == static_cast<HRESULT>(0x88760873) || result == static_cast<HRESULT>(0x88760872)) + { + return EGL_BAD_MATCH; + } + + // http://crbug.com/313210 + // If our swap failed, trigger a device lost event. Resetting will work around an AMD-specific + // device removed bug with lost contexts when reinstalling drivers. + if (FAILED(result)) + { + mRenderer->notifyDeviceLost(); + return EGL_CONTEXT_LOST; + } + + return EGL_SUCCESS; +} + +// Increments refcount on surface. +// caller must Release() the returned surface +// TODO: remove the AddRef to match SwapChain11 +IDirect3DSurface9 *SwapChain9::getRenderTarget() +{ + if (mRenderTarget) + { + mRenderTarget->AddRef(); + } + + return mRenderTarget; +} + +// Increments refcount on surface. +// caller must Release() the returned surface +// TODO: remove the AddRef to match SwapChain11 +IDirect3DSurface9 *SwapChain9::getDepthStencil() +{ + if (mDepthStencil) + { + mDepthStencil->AddRef(); + } + + return mDepthStencil; +} + +// Increments refcount on texture. +// caller must Release() the returned texture +// TODO: remove the AddRef to match SwapChain11 +IDirect3DTexture9 *SwapChain9::getOffscreenTexture() +{ + if (mOffscreenTexture) + { + mOffscreenTexture->AddRef(); + } + + return mOffscreenTexture; +} + +void *SwapChain9::getKeyedMutex() +{ + UNREACHABLE(); + return nullptr; +} + +egl::Error SwapChain9::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) +{ + UNREACHABLE(); + return egl::EglBadSurface(); +} + +void SwapChain9::recreate() +{ + if (!mSwapChain) + { + return; + } + + IDirect3DDevice9 *device = mRenderer->getDevice(); + if (device == nullptr) + { + return; + } + + D3DPRESENT_PARAMETERS presentParameters; + HRESULT result = mSwapChain->GetPresentParameters(&presentParameters); + ASSERT(SUCCEEDED(result)); + + IDirect3DSwapChain9 *newSwapChain = nullptr; + result = device->CreateAdditionalSwapChain(&presentParameters, &newSwapChain); + if (FAILED(result)) + { + return; + } + + SafeRelease(mSwapChain); + mSwapChain = newSwapChain; + + SafeRelease(mBackBuffer); + result = mSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mBackBuffer); + ASSERT(SUCCEEDED(result)); +} + +RenderTargetD3D *SwapChain9::getColorRenderTarget() +{ + return &mColorRenderTarget; +} + +RenderTargetD3D *SwapChain9::getDepthStencilRenderTarget() +{ + return &mDepthStencilRenderTarget; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h new file mode 100644 index 0000000000..2b3176967d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h @@ -0,0 +1,80 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SwapChain9.h: Defines a back-end specific class for the D3D9 swap chain. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_SWAPCHAIN9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_SWAPCHAIN9_H_ + +#include "common/angleutils.h" +#include "libANGLE/renderer/d3d/SwapChainD3D.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" + +namespace rx +{ +class NativeWindow9; +class Renderer9; + +class SwapChain9 : public SwapChainD3D +{ + public: + SwapChain9(Renderer9 *renderer, + NativeWindow9 *nativeWindow, + HANDLE shareHandle, + IUnknown *d3dTexture, + GLenum backBufferFormat, + GLenum depthBufferFormat, + EGLint orientation); + ~SwapChain9() override; + + EGLint resize(DisplayD3D *displayD3D, EGLint backbufferWidth, EGLint backbufferHeight) override; + EGLint reset(DisplayD3D *displayD3D, + EGLint backbufferWidth, + EGLint backbufferHeight, + EGLint swapInterval) override; + EGLint swapRect(DisplayD3D *displayD3D, + EGLint x, + EGLint y, + EGLint width, + EGLint height) override; + void recreate() override; + + RenderTargetD3D *getColorRenderTarget() override; + RenderTargetD3D *getDepthStencilRenderTarget() override; + + virtual IDirect3DSurface9 *getRenderTarget(); + virtual IDirect3DSurface9 *getDepthStencil(); + virtual IDirect3DTexture9 *getOffscreenTexture(); + + EGLint getWidth() const { return mWidth; } + EGLint getHeight() const { return mHeight; } + + void *getKeyedMutex() override; + + egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override; + + private: + void release(); + + Renderer9 *mRenderer; + EGLint mWidth; + EGLint mHeight; + EGLint mSwapInterval; + + NativeWindow9 *mNativeWindow; + + IDirect3DSwapChain9 *mSwapChain; + IDirect3DSurface9 *mBackBuffer; + IDirect3DSurface9 *mRenderTarget; + IDirect3DSurface9 *mDepthStencil; + IDirect3DTexture9 *mOffscreenTexture; + + SurfaceRenderTarget9 mColorRenderTarget; + SurfaceRenderTarget9 mDepthStencilRenderTarget; +}; + +} // namespace rx +#endif // LIBANGLE_RENDERER_D3D_D3D9_SWAPCHAIN9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp new file mode 100644 index 0000000000..b2fea07fd5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp @@ -0,0 +1,575 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureStorage9.cpp: Implements the abstract rx::TextureStorage9 class and its concrete derived +// classes TextureStorage9_2D and TextureStorage9_Cube, which act as the interface to the +// D3D9 texture. + +#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h" + +#include "common/utilities.h" +#include "libANGLE/Context.h" +#include "libANGLE/Texture.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/EGLImageD3D.h" +#include "libANGLE/renderer/d3d/TextureD3D.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/SwapChain9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +namespace rx +{ +TextureStorage9::TextureStorage9(Renderer9 *renderer, DWORD usage, const std::string &label) + : TextureStorage(label), + mTopLevel(0), + mMipLevels(0), + mTextureWidth(0), + mTextureHeight(0), + mInternalFormat(GL_NONE), + mTextureFormat(D3DFMT_UNKNOWN), + mRenderer(renderer), + mD3DUsage(usage), + mD3DPool(mRenderer->getTexturePool(usage)) +{} + +TextureStorage9::~TextureStorage9() {} + +DWORD TextureStorage9::GetTextureUsage(GLenum internalformat, bool renderTarget) +{ + DWORD d3dusage = 0; + + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalformat); + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat); + if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) + { + d3dusage |= D3DUSAGE_DEPTHSTENCIL; + } + else if (renderTarget && (d3dFormatInfo.renderFormat != D3DFMT_UNKNOWN)) + { + d3dusage |= D3DUSAGE_RENDERTARGET; + } + + return d3dusage; +} + +bool TextureStorage9::isRenderTarget() const +{ + return (mD3DUsage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL)) != 0; +} + +bool TextureStorage9::isManaged() const +{ + return (mD3DPool == D3DPOOL_MANAGED); +} + +bool TextureStorage9::supportsNativeMipmapFunction() const +{ + return false; +} + +D3DPOOL TextureStorage9::getPool() const +{ + return mD3DPool; +} + +DWORD TextureStorage9::getUsage() const +{ + return mD3DUsage; +} + +int TextureStorage9::getTopLevel() const +{ + return mTopLevel; +} + +int TextureStorage9::getLevelCount() const +{ + return static_cast<int>(mMipLevels) - mTopLevel; +} + +angle::Result TextureStorage9::setData(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D *image, + const gl::Box *destBox, + GLenum type, + const gl::PixelUnpackState &unpack, + const uint8_t *pixelData) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, + SwapChain9 *swapchain, + const std::string &label) + : TextureStorage9(renderer, D3DUSAGE_RENDERTARGET, label) +{ + IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture(); + mTexture = surfaceTexture; + mMipLevels = surfaceTexture->GetLevelCount(); + + mInternalFormat = swapchain->getRenderTargetInternalFormat(); + + D3DSURFACE_DESC surfaceDesc; + surfaceTexture->GetLevelDesc(0, &surfaceDesc); + mTextureWidth = surfaceDesc.Width; + mTextureHeight = surfaceDesc.Height; + mTextureFormat = surfaceDesc.Format; + + mRenderTargets.resize(mMipLevels, nullptr); +} + +TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, + GLenum internalformat, + bool renderTarget, + GLsizei width, + GLsizei height, + int levels, + const std::string &label) + : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget), label) +{ + mTexture = nullptr; + + mInternalFormat = internalformat; + + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat); + mTextureFormat = d3dFormatInfo.texFormat; + + d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &width, &height, &mTopLevel); + mTextureWidth = width; + mTextureHeight = height; + mMipLevels = mTopLevel + levels; + + mRenderTargets.resize(levels, nullptr); +} + +TextureStorage9_2D::~TextureStorage9_2D() +{ + SafeRelease(mTexture); + for (RenderTargetD3D *renderTarget : mRenderTargets) + { + SafeDelete(renderTarget); + } +} + +// Increments refcount on surface. +// caller must Release() the returned surface +angle::Result TextureStorage9_2D::getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) +{ + ASSERT(target == gl::TextureTarget::_2D); + + IDirect3DBaseTexture9 *baseTexture = nullptr; + ANGLE_TRY(getBaseTexture(context, &baseTexture)); + + IDirect3DTexture9 *texture = static_cast<IDirect3DTexture9 *>(baseTexture); + + HRESULT result = texture->GetSurfaceLevel(level + mTopLevel, outSurface); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture"); + + // With managed textures the driver needs to be informed of updates to the lower mipmap levels + if (level + mTopLevel != 0 && isManaged() && dirty) + { + texture->AddDirtyRect(nullptr); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage9_2D::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(index.getLevelIndex() < getLevelCount()); + + ASSERT(outRT); + *outRT = mRenderTargets[index.getLevelIndex()]; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_2D::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(index.getLevelIndex() < getLevelCount()); + + if (!mRenderTargets[index.getLevelIndex()] && isRenderTarget()) + { + IDirect3DBaseTexture9 *baseTexture = nullptr; + ANGLE_TRY(getBaseTexture(context, &baseTexture)); + + IDirect3DSurface9 *surface = nullptr; + ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, index.getLevelIndex(), false, + &surface)); + + size_t textureMipLevel = mTopLevel + index.getLevelIndex(); + size_t mipWidth = std::max<size_t>(mTextureWidth >> textureMipLevel, 1u); + size_t mipHeight = std::max<size_t>(mTextureHeight >> textureMipLevel, 1u); + + baseTexture->AddRef(); + mRenderTargets[index.getLevelIndex()] = new TextureRenderTarget9( + baseTexture, textureMipLevel, surface, mInternalFormat, static_cast<GLsizei>(mipWidth), + static_cast<GLsizei>(mipHeight), 1, 0); + } + + ASSERT(outRT); + *outRT = mRenderTargets[index.getLevelIndex()]; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_2D::generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) +{ + angle::ComPtr<IDirect3DSurface9> upper = nullptr; + ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, sourceIndex.getLevelIndex(), false, + &upper)); + + angle::ComPtr<IDirect3DSurface9> lower = nullptr; + ANGLE_TRY( + getSurfaceLevel(context, gl::TextureTarget::_2D, destIndex.getLevelIndex(), true, &lower)); + + ASSERT(upper && lower); + return mRenderer->boxFilter(GetImplAs<Context9>(context), upper.Get(), lower.Get()); +} + +angle::Result TextureStorage9_2D::getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) +{ + // 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 == nullptr && mTextureWidth > 0 && mTextureHeight > 0) + { + ASSERT(mMipLevels > 0); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + HRESULT result = device->CreateTexture(static_cast<unsigned int>(mTextureWidth), + static_cast<unsigned int>(mTextureHeight), + static_cast<unsigned int>(mMipLevels), getUsage(), + mTextureFormat, getPool(), &mTexture, nullptr); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to create 2D storage texture"); + } + + *outTexture = mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_2D::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + + TextureStorage9_2D *dest9 = GetAs<TextureStorage9_2D>(destStorage); + + int levels = getLevelCount(); + for (int i = 0; i < levels; ++i) + { + angle::ComPtr<IDirect3DSurface9> srcSurf = nullptr; + ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, i, false, &srcSurf)); + + angle::ComPtr<IDirect3DSurface9> dstSurf = nullptr; + ANGLE_TRY(dest9->getSurfaceLevel(context, gl::TextureTarget::_2D, i, true, &dstSurf)); + + ANGLE_TRY( + mRenderer->copyToRenderTarget(context, dstSurf.Get(), srcSurf.Get(), isManaged())); + } + + return angle::Result::Continue; +} + +TextureStorage9_EGLImage::TextureStorage9_EGLImage(Renderer9 *renderer, + EGLImageD3D *image, + RenderTarget9 *renderTarget9, + const std::string &label) + : TextureStorage9(renderer, D3DUSAGE_RENDERTARGET, label), mImage(image) +{ + + mInternalFormat = renderTarget9->getInternalFormat(); + mTextureFormat = renderTarget9->getD3DFormat(); + mTextureWidth = renderTarget9->getWidth(); + mTextureHeight = renderTarget9->getHeight(); + mTopLevel = static_cast<int>(renderTarget9->getTextureLevel()); + mMipLevels = mTopLevel + 1; +} + +TextureStorage9_EGLImage::~TextureStorage9_EGLImage() {} + +angle::Result TextureStorage9_EGLImage::getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool, + IDirect3DSurface9 **outSurface) +{ + ASSERT(target == gl::TextureTarget::_2D); + ASSERT(level == 0); + + RenderTargetD3D *renderTargetD3D = nullptr; + ANGLE_TRY(mImage->getRenderTarget(context, &renderTargetD3D)); + + RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTargetD3D); + + *outSurface = renderTarget9->getSurface(); + return angle::Result::Continue; +} + +angle::Result TextureStorage9_EGLImage::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + // Since the render target of a EGL image will be updated when orphaning, trying to find a cache + // of it can be rarely useful. + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage9_EGLImage::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(!index.hasLayer()); + ASSERT(index.getLevelIndex() == 0); + ASSERT(samples == 0); + + return mImage->getRenderTarget(context, outRT); +} + +angle::Result TextureStorage9_EGLImage::getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) +{ + RenderTargetD3D *renderTargetD3D = nullptr; + ANGLE_TRY(mImage->getRenderTarget(context, &renderTargetD3D)); + + RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTargetD3D); + *outTexture = renderTarget9->getTexture(); + ASSERT(*outTexture != nullptr); + + return angle::Result::Continue; +} + +angle::Result TextureStorage9_EGLImage::generateMipmap(const gl::Context *context, + const gl::ImageIndex &, + const gl::ImageIndex &) +{ + ANGLE_HR_UNREACHABLE(GetImplAs<Context9>(context)); + return angle::Result::Stop; +} + +angle::Result TextureStorage9_EGLImage::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + ASSERT(getLevelCount() == 1); + + TextureStorage9 *dest9 = GetAs<TextureStorage9>(destStorage); + + IDirect3DBaseTexture9 *destBaseTexture9 = nullptr; + ANGLE_TRY(dest9->getBaseTexture(context, &destBaseTexture9)); + + IDirect3DTexture9 *destTexture9 = static_cast<IDirect3DTexture9 *>(destBaseTexture9); + + angle::ComPtr<IDirect3DSurface9> destSurface = nullptr; + HRESULT result = destTexture9->GetSurfaceLevel(destStorage->getTopLevel(), &destSurface); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture"); + + RenderTargetD3D *sourceRenderTarget = nullptr; + ANGLE_TRY(mImage->getRenderTarget(context, &sourceRenderTarget)); + + RenderTarget9 *sourceRenderTarget9 = GetAs<RenderTarget9>(sourceRenderTarget); + ANGLE_TRY(mRenderer->copyToRenderTarget(context, destSurface.Get(), + sourceRenderTarget9->getSurface(), isManaged())); + + if (destStorage->getTopLevel() != 0) + { + destTexture9->AddDirtyRect(nullptr); + } + + return angle::Result::Continue; +} + +TextureStorage9_Cube::TextureStorage9_Cube(Renderer9 *renderer, + GLenum internalformat, + bool renderTarget, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label) + : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget), label) +{ + mTexture = nullptr; + for (size_t i = 0; i < gl::kCubeFaceCount; ++i) + { + mRenderTarget[i] = nullptr; + } + + mInternalFormat = internalformat; + + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat); + mTextureFormat = d3dFormatInfo.texFormat; + + int height = size; + d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &size, &height, &mTopLevel); + mTextureWidth = size; + mTextureHeight = size; + mMipLevels = mTopLevel + levels; +} + +TextureStorage9_Cube::~TextureStorage9_Cube() +{ + SafeRelease(mTexture); + + for (size_t i = 0; i < gl::kCubeFaceCount; ++i) + { + SafeDelete(mRenderTarget[i]); + } +} + +// Increments refcount on surface. +// caller must Release() the returned surface +angle::Result TextureStorage9_Cube::getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) +{ + IDirect3DBaseTexture9 *baseTexture = nullptr; + ANGLE_TRY(getBaseTexture(context, &baseTexture)); + + IDirect3DCubeTexture9 *texture = static_cast<IDirect3DCubeTexture9 *>(baseTexture); + + D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(target); + HRESULT result = texture->GetCubeMapSurface(face, level, outSurface); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture"); + + // With managed textures the driver needs to be informed of updates to the lower mipmap levels + if (level != 0 && isManaged() && dirty) + { + texture->AddDirtyRect(face, nullptr); + } + + return angle::Result::Continue; +} + +angle::Result TextureStorage9_Cube::findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const +{ + ASSERT(outRT); + ASSERT(index.getLevelIndex() == 0); + ASSERT(samples == 0); + + ASSERT(index.getType() == gl::TextureType::CubeMap && + gl::IsCubeMapFaceTarget(index.getTarget())); + const size_t renderTargetIndex = index.cubeMapFaceIndex(); + + *outRT = mRenderTarget[renderTargetIndex]; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_Cube::getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) +{ + ASSERT(outRT); + ASSERT(index.getLevelIndex() == 0); + ASSERT(samples == 0); + + ASSERT(index.getType() == gl::TextureType::CubeMap && + gl::IsCubeMapFaceTarget(index.getTarget())); + const size_t renderTargetIndex = index.cubeMapFaceIndex(); + + if (mRenderTarget[renderTargetIndex] == nullptr && isRenderTarget()) + { + IDirect3DBaseTexture9 *baseTexture = nullptr; + ANGLE_TRY(getBaseTexture(context, &baseTexture)); + + IDirect3DSurface9 *surface = nullptr; + ANGLE_TRY(getSurfaceLevel(context, index.getTarget(), mTopLevel + index.getLevelIndex(), + false, &surface)); + + baseTexture->AddRef(); + mRenderTarget[renderTargetIndex] = new TextureRenderTarget9( + baseTexture, mTopLevel + index.getLevelIndex(), surface, mInternalFormat, + static_cast<GLsizei>(mTextureWidth), static_cast<GLsizei>(mTextureHeight), 1, 0); + } + + *outRT = mRenderTarget[renderTargetIndex]; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_Cube::generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) +{ + angle::ComPtr<IDirect3DSurface9> upper = nullptr; + ANGLE_TRY(getSurfaceLevel(context, sourceIndex.getTarget(), sourceIndex.getLevelIndex(), false, + &upper)); + + angle::ComPtr<IDirect3DSurface9> lower = nullptr; + ANGLE_TRY( + getSurfaceLevel(context, destIndex.getTarget(), destIndex.getLevelIndex(), true, &lower)); + + ASSERT(upper && lower); + return mRenderer->boxFilter(GetImplAs<Context9>(context), upper.Get(), lower.Get()); +} + +angle::Result TextureStorage9_Cube::getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) +{ + // if the size is not positive this should be treated as an incomplete texture + // we handle that here by skipping the d3d texture creation + if (mTexture == nullptr && mTextureWidth > 0 && mTextureHeight > 0) + { + ASSERT(mMipLevels > 0); + ASSERT(mTextureWidth == mTextureHeight); + + IDirect3DDevice9 *device = mRenderer->getDevice(); + HRESULT result = device->CreateCubeTexture( + static_cast<unsigned int>(mTextureWidth), static_cast<unsigned int>(mMipLevels), + getUsage(), mTextureFormat, getPool(), &mTexture, nullptr); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to create cube storage texture"); + } + + *outTexture = mTexture; + return angle::Result::Continue; +} + +angle::Result TextureStorage9_Cube::copyToStorage(const gl::Context *context, + TextureStorage *destStorage) +{ + ASSERT(destStorage); + + TextureStorage9_Cube *dest9 = GetAs<TextureStorage9_Cube>(destStorage); + + int levels = getLevelCount(); + for (gl::TextureTarget face : gl::AllCubeFaceTextureTargets()) + { + for (int i = 0; i < levels; i++) + { + angle::ComPtr<IDirect3DSurface9> srcSurf = nullptr; + ANGLE_TRY(getSurfaceLevel(context, face, i, false, &srcSurf)); + + angle::ComPtr<IDirect3DSurface9> dstSurf = nullptr; + ANGLE_TRY(dest9->getSurfaceLevel(context, face, i, true, &dstSurf)); + + ANGLE_TRY( + mRenderer->copyToRenderTarget(context, dstSurf.Get(), srcSurf.Get(), isManaged())); + } + } + + return angle::Result::Continue; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h new file mode 100644 index 0000000000..9882c341f9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h @@ -0,0 +1,186 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TextureStorage9.h: Defines the abstract rx::TextureStorage9 class and its concrete derived +// classes TextureStorage9_2D and TextureStorage9_Cube, which act as the interface to the +// D3D9 texture. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_ + +#include "common/debug.h" +#include "libANGLE/renderer/d3d/TextureStorage.h" + +namespace rx +{ +class EGLImageD3D; +class Renderer9; +class SwapChain9; +class RenderTargetD3D; +class RenderTarget9; + +class TextureStorage9 : public TextureStorage +{ + public: + ~TextureStorage9() override; + + static DWORD GetTextureUsage(GLenum internalformat, bool renderTarget); + + D3DPOOL getPool() const; + DWORD getUsage() const; + + virtual angle::Result getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) = 0; + virtual angle::Result getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) = 0; + + int getTopLevel() const override; + bool isRenderTarget() const override; + bool isUnorderedAccess() const override { return false; } + bool isManaged() const override; + bool supportsNativeMipmapFunction() const override; + int getLevelCount() const override; + + angle::Result setData(const gl::Context *context, + const gl::ImageIndex &index, + ImageD3D *image, + const gl::Box *destBox, + GLenum type, + const gl::PixelUnpackState &unpack, + const uint8_t *pixelData) override; + + protected: + int mTopLevel; + size_t mMipLevels; + size_t mTextureWidth; + size_t mTextureHeight; + GLenum mInternalFormat; + D3DFORMAT mTextureFormat; + + Renderer9 *mRenderer; + + TextureStorage9(Renderer9 *renderer, DWORD usage, const std::string &label); + + private: + const DWORD mD3DUsage; + const D3DPOOL mD3DPool; +}; + +class TextureStorage9_2D : public TextureStorage9 +{ + public: + TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain, const std::string &label); + TextureStorage9_2D(Renderer9 *renderer, + GLenum internalformat, + bool renderTarget, + GLsizei width, + GLsizei height, + int levels, + const std::string &label); + ~TextureStorage9_2D() override; + + angle::Result getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + angle::Result getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) override; + angle::Result generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) override; + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + + private: + IDirect3DTexture9 *mTexture; + std::vector<RenderTarget9 *> mRenderTargets; +}; + +class TextureStorage9_EGLImage final : public TextureStorage9 +{ + public: + TextureStorage9_EGLImage(Renderer9 *renderer, + EGLImageD3D *image, + RenderTarget9 *renderTarget9, + const std::string &label); + ~TextureStorage9_EGLImage() override; + + angle::Result getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + angle::Result getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) override; + angle::Result generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) override; + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + + private: + EGLImageD3D *mImage; +}; + +class TextureStorage9_Cube : public TextureStorage9 +{ + public: + TextureStorage9_Cube(Renderer9 *renderer, + GLenum internalformat, + bool renderTarget, + int size, + int levels, + bool hintLevelZeroOnly, + const std::string &label); + + ~TextureStorage9_Cube() override; + + angle::Result getSurfaceLevel(const gl::Context *context, + gl::TextureTarget target, + int level, + bool dirty, + IDirect3DSurface9 **outSurface) override; + angle::Result findRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) const override; + angle::Result getRenderTarget(const gl::Context *context, + const gl::ImageIndex &index, + GLsizei samples, + RenderTargetD3D **outRT) override; + angle::Result getBaseTexture(const gl::Context *context, + IDirect3DBaseTexture9 **outTexture) override; + angle::Result generateMipmap(const gl::Context *context, + const gl::ImageIndex &sourceIndex, + const gl::ImageIndex &destIndex) override; + angle::Result copyToStorage(const gl::Context *context, TextureStorage *destStorage) override; + + private: + IDirect3DCubeTexture9 *mTexture; + RenderTarget9 *mRenderTarget[gl::kCubeFaceCount]; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_TEXTURESTORAGE9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexArray9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexArray9.h new file mode 100644 index 0000000000..a9c1ee7d4b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexArray9.h @@ -0,0 +1,57 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexArray9.h: Defines the rx::VertexArray9 class which implements rx::VertexArrayImpl. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_VERTEXARRAY9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_VERTEXARRAY9_H_ + +#include "libANGLE/Context.h" +#include "libANGLE/renderer/VertexArrayImpl.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" + +namespace rx +{ +class Renderer9; + +class VertexArray9 : public VertexArrayImpl +{ + public: + VertexArray9(const gl::VertexArrayState &data) : VertexArrayImpl(data) {} + + angle::Result syncState(const gl::Context *context, + const gl::VertexArray::DirtyBits &dirtyBits, + gl::VertexArray::DirtyAttribBitsArray *attribBits, + gl::VertexArray::DirtyBindingBitsArray *bindingBits) override; + + ~VertexArray9() override {} + + Serial getCurrentStateSerial() const { return mCurrentStateSerial; } + + private: + Serial mCurrentStateSerial; +}; + +inline angle::Result VertexArray9::syncState(const gl::Context *context, + const gl::VertexArray::DirtyBits &dirtyBits, + gl::VertexArray::DirtyAttribBitsArray *attribBits, + gl::VertexArray::DirtyBindingBitsArray *bindingBits) +{ + + ASSERT(dirtyBits.any()); + Renderer9 *renderer = GetImplAs<Context9>(context)->getRenderer(); + mCurrentStateSerial = renderer->generateSerial(); + + // Clear the dirty bits in the back-end here. + memset(attribBits, 0, sizeof(gl::VertexArray::DirtyAttribBitsArray)); + memset(bindingBits, 0, sizeof(gl::VertexArray::DirtyBindingBitsArray)); + + return angle::Result::Continue; +} +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_VERTEXARRAY9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp new file mode 100644 index 0000000000..915928686a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp @@ -0,0 +1,153 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer9.cpp: Defines the D3D9 VertexBuffer implementation. + +#include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h" + +#include "libANGLE/Buffer.h" +#include "libANGLE/Context.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/d3d/d3d9/vertexconversion.h" + +namespace rx +{ + +VertexBuffer9::VertexBuffer9(Renderer9 *renderer) : mRenderer(renderer) +{ + mVertexBuffer = nullptr; + mBufferSize = 0; + mDynamicUsage = false; +} + +VertexBuffer9::~VertexBuffer9() +{ + SafeRelease(mVertexBuffer); +} + +angle::Result VertexBuffer9::initialize(const gl::Context *context, + unsigned int size, + bool dynamicUsage) +{ + SafeRelease(mVertexBuffer); + + updateSerial(); + + if (size > 0) + { + DWORD flags = D3DUSAGE_WRITEONLY; + if (dynamicUsage) + { + flags |= D3DUSAGE_DYNAMIC; + } + + HRESULT result = mRenderer->createVertexBuffer(size, flags, &mVertexBuffer); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, + "Failed to allocate internal vertex buffer"); + } + + mBufferSize = size; + mDynamicUsage = dynamicUsage; + return angle::Result::Continue; +} + +angle::Result VertexBuffer9::storeVertexAttributes(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + unsigned int offset, + const uint8_t *sourceData) +{ + ASSERT(mVertexBuffer); + + size_t inputStride = gl::ComputeVertexAttributeStride(attrib, binding); + size_t elementSize = gl::ComputeVertexAttributeTypeSize(attrib); + + DWORD lockFlags = mDynamicUsage ? D3DLOCK_NOOVERWRITE : 0; + + uint8_t *mapPtr = nullptr; + + unsigned int mapSize = 0; + ANGLE_TRY( + mRenderer->getVertexSpaceRequired(context, attrib, binding, count, instances, 0, &mapSize)); + + HRESULT result = + mVertexBuffer->Lock(offset, mapSize, reinterpret_cast<void **>(&mapPtr), lockFlags); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to lock internal vertex buffer"); + + const uint8_t *input = sourceData; + + if (instances == 0 || binding.getDivisor() == 0) + { + input += inputStride * start; + } + + angle::FormatID vertexFormatID = gl::GetVertexFormatID(attrib, currentValueType); + const d3d9::VertexFormat &d3dVertexInfo = + d3d9::GetVertexFormatInfo(mRenderer->getCapsDeclTypes(), vertexFormatID); + bool needsConversion = (d3dVertexInfo.conversionType & VERTEX_CONVERT_CPU) > 0; + + if (!needsConversion && inputStride == elementSize) + { + size_t copySize = count * inputStride; + memcpy(mapPtr, input, copySize); + } + else + { + d3dVertexInfo.copyFunction(input, inputStride, count, mapPtr); + } + + mVertexBuffer->Unlock(); + + return angle::Result::Continue; +} + +unsigned int VertexBuffer9::getBufferSize() const +{ + return mBufferSize; +} + +angle::Result VertexBuffer9::setBufferSize(const gl::Context *context, unsigned int size) +{ + if (size > mBufferSize) + { + return initialize(context, size, mDynamicUsage); + } + else + { + return angle::Result::Continue; + } +} + +angle::Result VertexBuffer9::discard(const gl::Context *context) +{ + ASSERT(mVertexBuffer); + + void *mock; + HRESULT result; + + Context9 *context9 = GetImplAs<Context9>(context); + + result = mVertexBuffer->Lock(0, 1, &mock, D3DLOCK_DISCARD); + ANGLE_TRY_HR(context9, result, "Failed to lock internal vertex buffer for discarding"); + + result = mVertexBuffer->Unlock(); + ANGLE_TRY_HR(context9, result, "Failed to unlock internal vertex buffer for discarding"); + + return angle::Result::Continue; +} + +IDirect3DVertexBuffer9 *VertexBuffer9::getBuffer() const +{ + return mVertexBuffer; +} +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.h new file mode 100644 index 0000000000..d5c156e5f5 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.h @@ -0,0 +1,56 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexBuffer9.h: Defines the D3D9 VertexBuffer implementation. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_VERTEXBUFFER9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_VERTEXBUFFER9_H_ + +#include "libANGLE/renderer/d3d/VertexBuffer.h" + +namespace rx +{ +class Renderer9; + +class VertexBuffer9 : public VertexBuffer +{ + public: + explicit VertexBuffer9(Renderer9 *renderer); + + angle::Result initialize(const gl::Context *context, + unsigned int size, + bool dynamicUsage) override; + + // Warning: you should ensure binding really matches attrib.bindingIndex before using this + // function. + angle::Result storeVertexAttributes(const gl::Context *context, + const gl::VertexAttribute &attrib, + const gl::VertexBinding &binding, + gl::VertexAttribType currentValueType, + GLint start, + size_t count, + GLsizei instances, + unsigned int offset, + const uint8_t *sourceData) override; + + unsigned int getBufferSize() const override; + angle::Result setBufferSize(const gl::Context *context, unsigned int size) override; + angle::Result discard(const gl::Context *context) override; + + IDirect3DVertexBuffer9 *getBuffer() const; + + private: + ~VertexBuffer9() override; + Renderer9 *mRenderer; + + IDirect3DVertexBuffer9 *mVertexBuffer; + unsigned int mBufferSize; + bool mDynamicUsage; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_VERTEXBUFFER9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp new file mode 100644 index 0000000000..e129ae9786 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp @@ -0,0 +1,262 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexDeclarationCache.cpp: Implements a helper class to construct and cache vertex declarations. + +#include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h" + +#include "libANGLE/Context.h" +#include "libANGLE/VertexAttribute.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/d3d9/Context9.h" +#include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" + +namespace rx +{ + +VertexDeclarationCache::VertexDeclarationCache() : mMaxLru(0) +{ + for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++) + { + mVertexDeclCache[i].vertexDeclaration = nullptr; + mVertexDeclCache[i].lruCount = 0; + } + + for (VBData &vb : mAppliedVBs) + { + vb.serial = 0; + } + + mLastSetVDecl = nullptr; + mInstancingEnabled = true; +} + +VertexDeclarationCache::~VertexDeclarationCache() +{ + for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++) + { + SafeRelease(mVertexDeclCache[i].vertexDeclaration); + } +} + +angle::Result VertexDeclarationCache::applyDeclaration( + const gl::Context *context, + IDirect3DDevice9 *device, + const std::vector<TranslatedAttribute> &attributes, + gl::Program *program, + GLint start, + GLsizei instances, + GLsizei *repeatDraw) +{ + ASSERT(gl::MAX_VERTEX_ATTRIBS >= attributes.size()); + + *repeatDraw = 1; + + const size_t invalidAttribIndex = attributes.size(); + size_t indexedAttribute = invalidAttribIndex; + size_t instancedAttribute = invalidAttribIndex; + + if (instances == 0) + { + for (size_t i = 0; i < attributes.size(); ++i) + { + if (attributes[i].divisor != 0) + { + // If a divisor is set, it still applies even if an instanced draw was not used, so + // treat as a single-instance draw. + instances = 1; + break; + } + } + } + + if (instances > 0) + { + // Find an indexed attribute to be mapped to D3D stream 0 + for (size_t i = 0; i < attributes.size(); i++) + { + if (attributes[i].active) + { + if (indexedAttribute == invalidAttribIndex && attributes[i].divisor == 0) + { + indexedAttribute = i; + } + else if (instancedAttribute == invalidAttribIndex && attributes[i].divisor != 0) + { + instancedAttribute = i; + } + if (indexedAttribute != invalidAttribIndex && + instancedAttribute != invalidAttribIndex) + break; // Found both an indexed and instanced attribute + } + } + + // The validation layer checks that there is at least one active attribute with a zero + // divisor as per the GL_ANGLE_instanced_arrays spec. + ASSERT(indexedAttribute != invalidAttribIndex); + } + + D3DCAPS9 caps; + device->GetDeviceCaps(&caps); + + D3DVERTEXELEMENT9 elements[gl::MAX_VERTEX_ATTRIBS + 1]; + D3DVERTEXELEMENT9 *element = &elements[0]; + + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + const auto &semanticIndexes = programD3D->getAttribLocationToD3DSemantics(); + + for (size_t i = 0; i < attributes.size(); i++) + { + if (attributes[i].active) + { + // Directly binding the storage buffer is not supported for d3d9 + ASSERT(attributes[i].storage == nullptr); + + int stream = static_cast<int>(i); + + if (instances > 0) + { + // Due to a bug on ATI cards we can't enable instancing when none of the attributes + // are instanced. + if (instancedAttribute == invalidAttribIndex) + { + *repeatDraw = instances; + } + else + { + if (i == indexedAttribute) + { + stream = 0; + } + else if (i == 0) + { + stream = static_cast<int>(indexedAttribute); + } + + UINT frequency = 1; + + if (attributes[i].divisor == 0) + { + frequency = D3DSTREAMSOURCE_INDEXEDDATA | instances; + } + else + { + frequency = D3DSTREAMSOURCE_INSTANCEDATA | attributes[i].divisor; + } + + device->SetStreamSourceFreq(stream, frequency); + mInstancingEnabled = true; + } + } + + VertexBuffer9 *vertexBuffer = GetAs<VertexBuffer9>(attributes[i].vertexBuffer.get()); + + unsigned int offset = 0; + ANGLE_TRY(attributes[i].computeOffset(context, start, &offset)); + + if (mAppliedVBs[stream].serial != attributes[i].serial || + mAppliedVBs[stream].stride != attributes[i].stride || + mAppliedVBs[stream].offset != offset) + { + device->SetStreamSource(stream, vertexBuffer->getBuffer(), offset, + attributes[i].stride); + mAppliedVBs[stream].serial = attributes[i].serial; + mAppliedVBs[stream].stride = attributes[i].stride; + mAppliedVBs[stream].offset = offset; + } + + angle::FormatID vertexformatID = + gl::GetVertexFormatID(*attributes[i].attribute, gl::VertexAttribType::Float); + const d3d9::VertexFormat &d3d9VertexInfo = + d3d9::GetVertexFormatInfo(caps.DeclTypes, vertexformatID); + + element->Stream = static_cast<WORD>(stream); + element->Offset = 0; + element->Type = static_cast<BYTE>(d3d9VertexInfo.nativeFormat); + element->Method = D3DDECLMETHOD_DEFAULT; + element->Usage = D3DDECLUSAGE_TEXCOORD; + element->UsageIndex = static_cast<BYTE>(semanticIndexes[i]); + element++; + } + } + + if (instances == 0 || instancedAttribute == invalidAttribIndex) + { + if (mInstancingEnabled) + { + for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) + { + device->SetStreamSourceFreq(i, 1); + } + + mInstancingEnabled = false; + } + } + + static const D3DVERTEXELEMENT9 end = D3DDECL_END(); + *(element++) = end; + + for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++) + { + VertexDeclCacheEntry *entry = &mVertexDeclCache[i]; + if (memcmp(entry->cachedElements, elements, + (element - elements) * sizeof(D3DVERTEXELEMENT9)) == 0 && + entry->vertexDeclaration) + { + entry->lruCount = ++mMaxLru; + if (entry->vertexDeclaration != mLastSetVDecl) + { + device->SetVertexDeclaration(entry->vertexDeclaration); + mLastSetVDecl = entry->vertexDeclaration; + } + + return angle::Result::Continue; + } + } + + VertexDeclCacheEntry *lastCache = mVertexDeclCache; + + for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++) + { + if (mVertexDeclCache[i].lruCount < lastCache->lruCount) + { + lastCache = &mVertexDeclCache[i]; + } + } + + if (lastCache->vertexDeclaration != nullptr) + { + SafeRelease(lastCache->vertexDeclaration); + // mLastSetVDecl is set to the replacement, so we don't have to worry + // about it. + } + + memcpy(lastCache->cachedElements, elements, (element - elements) * sizeof(D3DVERTEXELEMENT9)); + HRESULT result = device->CreateVertexDeclaration(elements, &lastCache->vertexDeclaration); + ANGLE_TRY_HR(GetImplAs<Context9>(context), result, + "Failed to create internal vertex declaration"); + + device->SetVertexDeclaration(lastCache->vertexDeclaration); + mLastSetVDecl = lastCache->vertexDeclaration; + lastCache->lruCount = ++mMaxLru; + + return angle::Result::Continue; +} + +void VertexDeclarationCache::markStateDirty() +{ + for (VBData &vb : mAppliedVBs) + { + vb.serial = 0; + } + + mLastSetVDecl = nullptr; + mInstancingEnabled = true; // Forces it to be disabled when not used +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h new file mode 100644 index 0000000000..22e677d800 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h @@ -0,0 +1,68 @@ +// +// Copyright 2012 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// VertexDeclarationCache.h: Defines a helper class to construct and cache vertex declarations. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_VERTEXDECLARATIONCACHE_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_VERTEXDECLARATIONCACHE_H_ + +#include "libANGLE/Error.h" +#include "libANGLE/renderer/d3d/VertexDataManager.h" + +namespace gl +{ +class VertexDataManager; +class Program; +} // namespace gl + +namespace rx +{ +class VertexDeclarationCache +{ + public: + VertexDeclarationCache(); + ~VertexDeclarationCache(); + + angle::Result applyDeclaration(const gl::Context *context, + IDirect3DDevice9 *device, + const std::vector<TranslatedAttribute> &attributes, + gl::Program *program, + GLint start, + GLsizei instances, + GLsizei *repeatDraw); + + void markStateDirty(); + + private: + UINT mMaxLru; + + enum + { + NUM_VERTEX_DECL_CACHE_ENTRIES = 32 + }; + + struct VBData + { + unsigned int serial; + unsigned int stride; + unsigned int offset; + }; + + VBData mAppliedVBs[gl::MAX_VERTEX_ATTRIBS]; + IDirect3DVertexDeclaration9 *mLastSetVDecl; + bool mInstancingEnabled; + + struct VertexDeclCacheEntry + { + D3DVERTEXELEMENT9 cachedElements[gl::MAX_VERTEX_ATTRIBS + 1]; + UINT lruCount; + IDirect3DVertexDeclaration9 *vertexDeclaration; + } mVertexDeclCache[NUM_VERTEX_DECL_CACHE_ENTRIES]; +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_VERTEXDECLARATIONCACHE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.cpp new file mode 100644 index 0000000000..19a10b9cfb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.cpp @@ -0,0 +1,695 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// formatutils9.cpp: Queries for GL image formats and their translations to D3D9 +// formats. + +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" + +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + +#include "anglebase/no_destructor.h" +#include "libANGLE/renderer/d3d/d3d9/Renderer9.h" +#include "libANGLE/renderer/d3d/d3d9/vertexconversion.h" + +using namespace angle; + +namespace rx +{ + +namespace d3d9 +{ + +constexpr D3DFORMAT D3DFMT_INTZ = ((D3DFORMAT)(MAKEFOURCC('I', 'N', 'T', 'Z'))); +constexpr D3DFORMAT D3DFMT_NULL = ((D3DFORMAT)(MAKEFOURCC('N', 'U', 'L', 'L'))); + +// A map to determine the pixel size and mip generation function of a given D3D format +typedef std::map<D3DFORMAT, D3DFormat> D3D9FormatInfoMap; + +typedef std::pair<GLint, InitializeTextureDataFunction> InternalFormatInitialzerPair; +typedef std::map<GLint, InitializeTextureDataFunction> InternalFormatInitialzerMap; + +static InternalFormatInitialzerMap BuildInternalFormatInitialzerMap() +{ + using namespace angle; // For image initialization functions + + InternalFormatInitialzerMap map; + + map.insert(InternalFormatInitialzerPair( + GL_RGB16F, Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>)); + map.insert(InternalFormatInitialzerPair( + GL_RGB32F, + Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>)); + + return map; +} + +static void UnreachableLoad(size_t width, + size_t height, + size_t depth, + const uint8_t *input, + size_t inputRowPitch, + size_t inputDepthPitch, + uint8_t *output, + size_t outputRowPitch, + size_t outputDepthPitch) +{ + UNREACHABLE(); +} + +typedef std::pair<GLenum, TextureFormat> D3D9FormatPair; +typedef std::map<GLenum, TextureFormat> D3D9FormatMap; + +TextureFormat::TextureFormat() + : texFormat(D3DFMT_UNKNOWN), + renderFormat(D3DFMT_UNKNOWN), + dataInitializerFunction(nullptr), + loadFunction(UnreachableLoad) +{} + +static inline void InsertD3D9FormatInfo(D3D9FormatMap *map, + GLenum internalFormat, + D3DFORMAT texFormat, + D3DFORMAT renderFormat, + LoadImageFunction loadFunction) +{ + TextureFormat info; + info.texFormat = texFormat; + info.renderFormat = renderFormat; + + static const angle::base::NoDestructor<InternalFormatInitialzerMap> dataInitializationMap( + BuildInternalFormatInitialzerMap()); + InternalFormatInitialzerMap::const_iterator dataInitIter = + dataInitializationMap->find(internalFormat); + info.dataInitializerFunction = + (dataInitIter != dataInitializationMap->end()) ? dataInitIter->second : nullptr; + + info.loadFunction = loadFunction; + + map->insert(std::make_pair(internalFormat, info)); +} + +static D3D9FormatMap BuildD3D9FormatMap() +{ + using namespace angle; // For image loading functions + + D3D9FormatMap map; + + // clang-format off + // | Internal format | Texture format | Render format | Load function | + InsertD3D9FormatInfo(&map, GL_NONE, D3DFMT_NULL, D3DFMT_NULL, UnreachableLoad ); + + // We choose to downsample the GL_DEPTH_COMPONENT32_OES format to a 24-bit format because D3DFMT_D32 is not widely + // supported. We're allowed to do this because: + // - The ES spec 2.0.25 sec 3.7.1 states that we're allowed to store texture formats with internal format + // resolutions of our own choosing. + // - OES_depth_texture states that downsampling of the depth formats is allowed. + // - ANGLE_depth_texture does not state minimum required resolutions of the depth texture formats it + // introduces. + // In ES3 however, there are minimum resolutions for the texture formats and this would not be allowed. + + InsertD3D9FormatInfo(&map, GL_DEPTH_COMPONENT16, D3DFMT_INTZ, D3DFMT_D24S8, UnreachableLoad ); + InsertD3D9FormatInfo(&map, GL_DEPTH_COMPONENT32_OES, D3DFMT_INTZ, D3DFMT_D24X8, UnreachableLoad ); + InsertD3D9FormatInfo(&map, GL_DEPTH24_STENCIL8_OES, D3DFMT_INTZ, D3DFMT_D24S8, UnreachableLoad ); + InsertD3D9FormatInfo(&map, GL_STENCIL_INDEX8, D3DFMT_UNKNOWN, D3DFMT_D24S8, UnreachableLoad ); // TODO: What's the texture format? + + InsertD3D9FormatInfo(&map, GL_RGBA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F, LoadToNative<GLfloat, 4> ); + InsertD3D9FormatInfo(&map, GL_RGB32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F, LoadToNative3To4<GLfloat, gl::Float32One>); + InsertD3D9FormatInfo(&map, GL_RG32F_EXT, D3DFMT_G32R32F, D3DFMT_G32R32F, LoadToNative<GLfloat, 2> ); + InsertD3D9FormatInfo(&map, GL_R32F_EXT, D3DFMT_R32F, D3DFMT_R32F, LoadToNative<GLfloat, 1> ); + InsertD3D9FormatInfo(&map, GL_ALPHA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadA32FToRGBA32F ); + InsertD3D9FormatInfo(&map, GL_LUMINANCE32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadL32FToRGBA32F ); + InsertD3D9FormatInfo(&map, GL_LUMINANCE_ALPHA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadLA32FToRGBA32F ); + + InsertD3D9FormatInfo(&map, GL_RGBA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F, LoadToNative<GLhalf, 4> ); + InsertD3D9FormatInfo(&map, GL_RGB16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F, LoadToNative3To4<GLhalf, gl::Float16One> ); + InsertD3D9FormatInfo(&map, GL_RG16F_EXT, D3DFMT_G16R16F, D3DFMT_G16R16F, LoadToNative<GLhalf, 2> ); + InsertD3D9FormatInfo(&map, GL_R16F_EXT, D3DFMT_R16F, D3DFMT_R16F, LoadToNative<GLhalf, 1> ); + InsertD3D9FormatInfo(&map, GL_ALPHA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadA16FToRGBA16F ); + InsertD3D9FormatInfo(&map, GL_LUMINANCE16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadL16FToRGBA16F ); + InsertD3D9FormatInfo(&map, GL_LUMINANCE_ALPHA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadLA16FToRGBA16F ); + + InsertD3D9FormatInfo(&map, GL_ALPHA8_EXT, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadA8ToBGRA8 ); + + InsertD3D9FormatInfo(&map, GL_RGB8_OES, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadRGB8ToBGRX8 ); + InsertD3D9FormatInfo(&map, GL_RGB565, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadR5G6B5ToBGRA8 ); + InsertD3D9FormatInfo(&map, GL_RGBA8_OES, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGBA8ToBGRA8 ); + InsertD3D9FormatInfo(&map, GL_RGBA4, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGBA4ToBGRA8 ); + InsertD3D9FormatInfo(&map, GL_RGB5_A1, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGB5A1ToBGRA8 ); + InsertD3D9FormatInfo(&map, GL_R8_EXT, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadR8ToBGRX8 ); + InsertD3D9FormatInfo(&map, GL_RG8_EXT, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadRG8ToBGRX8 ); + + InsertD3D9FormatInfo(&map, GL_SRGB8, D3DFMT_X8R8G8B8, D3DFMT_UNKNOWN, LoadRGB8ToBGRX8 ); + InsertD3D9FormatInfo(&map, GL_SRGB8_ALPHA8_EXT, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGBA8ToBGRA8 ); + + InsertD3D9FormatInfo(&map, GL_BGRA8_EXT, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadToNative<GLubyte, 4> ); + InsertD3D9FormatInfo(&map, GL_BGRA4_ANGLEX, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadBGRA4ToBGRA8 ); + InsertD3D9FormatInfo(&map, GL_BGR5_A1_ANGLEX, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadBGR5A1ToBGRA8 ); + + InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, D3DFMT_DXT3, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, D3DFMT_DXT5, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> ); + + InsertD3D9FormatInfo(&map, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, D3DFMT_DXT3, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> ); + InsertD3D9FormatInfo(&map, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, D3DFMT_DXT5, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> ); + + // These formats require checking if the renderer supports D3DFMT_L8 or D3DFMT_A8L8 and + // then changing the format and loading function appropriately. + InsertD3D9FormatInfo(&map, GL_LUMINANCE8_EXT, D3DFMT_L8, D3DFMT_UNKNOWN, LoadToNative<GLubyte, 1> ); + InsertD3D9FormatInfo(&map, GL_LUMINANCE8_ALPHA8_EXT, D3DFMT_A8L8, D3DFMT_UNKNOWN, LoadToNative<GLubyte, 2> ); + // clang-format on + + return map; +} + +const TextureFormat &GetTextureFormatInfo(GLenum internalFormat) +{ + static const angle::base::NoDestructor<D3D9FormatMap> formatMap(BuildD3D9FormatMap()); + D3D9FormatMap::const_iterator iter = formatMap->find(internalFormat); + if (iter != formatMap->end()) + { + return iter->second; + } + else + { + static const TextureFormat defaultInfo; + return defaultInfo; + } +} + +static GLenum GetDeclTypeComponentType(D3DDECLTYPE declType) +{ + switch (declType) + { + case D3DDECLTYPE_FLOAT1: + return GL_FLOAT; + case D3DDECLTYPE_FLOAT2: + return GL_FLOAT; + case D3DDECLTYPE_FLOAT3: + return GL_FLOAT; + case D3DDECLTYPE_FLOAT4: + return GL_FLOAT; + case D3DDECLTYPE_UBYTE4: + return GL_UNSIGNED_INT; + case D3DDECLTYPE_SHORT2: + return GL_INT; + case D3DDECLTYPE_SHORT4: + return GL_INT; + case D3DDECLTYPE_UBYTE4N: + return GL_UNSIGNED_NORMALIZED; + case D3DDECLTYPE_SHORT4N: + return GL_SIGNED_NORMALIZED; + case D3DDECLTYPE_USHORT4N: + return GL_UNSIGNED_NORMALIZED; + case D3DDECLTYPE_SHORT2N: + return GL_SIGNED_NORMALIZED; + case D3DDECLTYPE_USHORT2N: + return GL_UNSIGNED_NORMALIZED; + default: + UNREACHABLE(); + return GL_NONE; + } +} + +// Attribute format conversion +enum +{ + NUM_GL_VERTEX_ATTRIB_TYPES = 6 +}; + +struct TranslationDescription +{ + DWORD capsFlag; + VertexFormat preferredConversion; + VertexFormat fallbackConversion; +}; + +// Mapping from OpenGL-ES vertex attrib type to D3D decl type: +// +// BYTE SHORT (Cast) +// BYTE-norm FLOAT (Normalize) (can't be exactly represented as SHORT-norm) +// UNSIGNED_BYTE UBYTE4 (Identity) or SHORT (Cast) +// UNSIGNED_BYTE-norm UBYTE4N (Identity) or FLOAT (Normalize) +// SHORT SHORT (Identity) +// SHORT-norm SHORT-norm (Identity) or FLOAT (Normalize) +// UNSIGNED_SHORT FLOAT (Cast) +// UNSIGNED_SHORT-norm USHORT-norm (Identity) or FLOAT (Normalize) +// FIXED (not in WebGL) FLOAT (FixedToFloat) +// FLOAT FLOAT (Identity) + +// GLToCType maps from GL type (as GLenum) to the C typedef. +template <GLenum GLType> +struct GLToCType +{}; + +template <> +struct GLToCType<GL_BYTE> +{ + typedef GLbyte type; +}; +template <> +struct GLToCType<GL_UNSIGNED_BYTE> +{ + typedef GLubyte type; +}; +template <> +struct GLToCType<GL_SHORT> +{ + typedef GLshort type; +}; +template <> +struct GLToCType<GL_UNSIGNED_SHORT> +{ + typedef GLushort type; +}; +template <> +struct GLToCType<GL_FIXED> +{ + typedef GLuint type; +}; +template <> +struct GLToCType<GL_FLOAT> +{ + typedef GLfloat type; +}; + +// This differs from D3DDECLTYPE in that it is unsized. (Size expansion is applied last.) +enum D3DVertexType +{ + D3DVT_FLOAT, + D3DVT_SHORT, + D3DVT_SHORT_NORM, + D3DVT_UBYTE, + D3DVT_UBYTE_NORM, + D3DVT_USHORT_NORM +}; + +// D3DToCType maps from D3D vertex type (as enum D3DVertexType) to the corresponding C type. +template <unsigned int D3DType> +struct D3DToCType +{}; + +template <> +struct D3DToCType<D3DVT_FLOAT> +{ + typedef float type; +}; +template <> +struct D3DToCType<D3DVT_SHORT> +{ + typedef short type; +}; +template <> +struct D3DToCType<D3DVT_SHORT_NORM> +{ + typedef short type; +}; +template <> +struct D3DToCType<D3DVT_UBYTE> +{ + typedef unsigned char type; +}; +template <> +struct D3DToCType<D3DVT_UBYTE_NORM> +{ + typedef unsigned char type; +}; +template <> +struct D3DToCType<D3DVT_USHORT_NORM> +{ + typedef unsigned short type; +}; + +// Encode the type/size combinations that D3D permits. For each type/size it expands to a widener +// that will provide the appropriate final size. +template <unsigned int type, int size> +struct WidenRule +{}; + +template <int size> +struct WidenRule<D3DVT_FLOAT, size> : NoWiden<size> +{}; +template <int size> +struct WidenRule<D3DVT_SHORT, size> : WidenToEven<size> +{}; +template <int size> +struct WidenRule<D3DVT_SHORT_NORM, size> : WidenToEven<size> +{}; +template <int size> +struct WidenRule<D3DVT_UBYTE, size> : WidenToFour<size> +{}; +template <int size> +struct WidenRule<D3DVT_UBYTE_NORM, size> : WidenToFour<size> +{}; +template <int size> +struct WidenRule<D3DVT_USHORT_NORM, size> : WidenToEven<size> +{}; + +// VertexTypeFlags encodes the D3DCAPS9::DeclType flag and vertex declaration flag for each D3D +// vertex type & size combination. +template <unsigned int d3dtype, int size> +struct VertexTypeFlags +{}; + +template <unsigned int _capflag, unsigned int _declflag> +struct VertexTypeFlagsHelper +{ + enum + { + capflag = _capflag + }; + enum + { + declflag = _declflag + }; +}; + +template <> +struct VertexTypeFlags<D3DVT_FLOAT, 1> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT1> +{}; +template <> +struct VertexTypeFlags<D3DVT_FLOAT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT2> +{}; +template <> +struct VertexTypeFlags<D3DVT_FLOAT, 3> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT3> +{}; +template <> +struct VertexTypeFlags<D3DVT_FLOAT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT4> +{}; +template <> +struct VertexTypeFlags<D3DVT_SHORT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT2> +{}; +template <> +struct VertexTypeFlags<D3DVT_SHORT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT4> +{}; +template <> +struct VertexTypeFlags<D3DVT_SHORT_NORM, 2> + : VertexTypeFlagsHelper<D3DDTCAPS_SHORT2N, D3DDECLTYPE_SHORT2N> +{}; +template <> +struct VertexTypeFlags<D3DVT_SHORT_NORM, 4> + : VertexTypeFlagsHelper<D3DDTCAPS_SHORT4N, D3DDECLTYPE_SHORT4N> +{}; +template <> +struct VertexTypeFlags<D3DVT_UBYTE, 4> : VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4, D3DDECLTYPE_UBYTE4> +{}; +template <> +struct VertexTypeFlags<D3DVT_UBYTE_NORM, 4> + : VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4N, D3DDECLTYPE_UBYTE4N> +{}; +template <> +struct VertexTypeFlags<D3DVT_USHORT_NORM, 2> + : VertexTypeFlagsHelper<D3DDTCAPS_USHORT2N, D3DDECLTYPE_USHORT2N> +{}; +template <> +struct VertexTypeFlags<D3DVT_USHORT_NORM, 4> + : VertexTypeFlagsHelper<D3DDTCAPS_USHORT4N, D3DDECLTYPE_USHORT4N> +{}; + +// VertexTypeMapping maps GL type & normalized flag to preferred and fallback D3D vertex types (as +// D3DVertexType enums). +template <GLenum GLtype, bool normalized> +struct VertexTypeMapping +{}; + +template <D3DVertexType Preferred, D3DVertexType Fallback = Preferred> +struct VertexTypeMappingBase +{ + enum + { + preferred = Preferred + }; + enum + { + fallback = Fallback + }; +}; + +template <> +struct VertexTypeMapping<GL_BYTE, false> : VertexTypeMappingBase<D3DVT_SHORT> +{}; // Cast +template <> +struct VertexTypeMapping<GL_BYTE, true> : VertexTypeMappingBase<D3DVT_FLOAT> +{}; // Normalize +template <> +struct VertexTypeMapping<GL_UNSIGNED_BYTE, false> : VertexTypeMappingBase<D3DVT_UBYTE, D3DVT_FLOAT> +{}; // Identity, Cast +template <> +struct VertexTypeMapping<GL_UNSIGNED_BYTE, true> + : VertexTypeMappingBase<D3DVT_UBYTE_NORM, D3DVT_FLOAT> +{}; // Identity, Normalize +template <> +struct VertexTypeMapping<GL_SHORT, false> : VertexTypeMappingBase<D3DVT_SHORT> +{}; // Identity +template <> +struct VertexTypeMapping<GL_SHORT, true> : VertexTypeMappingBase<D3DVT_SHORT_NORM, D3DVT_FLOAT> +{}; // Cast, Normalize +template <> +struct VertexTypeMapping<GL_UNSIGNED_SHORT, false> : VertexTypeMappingBase<D3DVT_FLOAT> +{}; // Cast +template <> +struct VertexTypeMapping<GL_UNSIGNED_SHORT, true> + : VertexTypeMappingBase<D3DVT_USHORT_NORM, D3DVT_FLOAT> +{}; // Cast, Normalize +template <bool normalized> +struct VertexTypeMapping<GL_FIXED, normalized> : VertexTypeMappingBase<D3DVT_FLOAT> +{}; // FixedToFloat +template <bool normalized> +struct VertexTypeMapping<GL_FLOAT, normalized> : VertexTypeMappingBase<D3DVT_FLOAT> +{}; // Identity + +// Given a GL type & norm flag and a D3D type, ConversionRule provides the type conversion rule +// (Cast, Normalize, Identity, FixedToFloat). The conversion rules themselves are defined in +// vertexconversion.h. + +// Almost all cases are covered by Cast (including those that are actually Identity since Cast<T,T> +// knows it's an identity mapping). +template <GLenum fromType, bool normalized, unsigned int toType> +struct ConversionRule : Cast<typename GLToCType<fromType>::type, typename D3DToCType<toType>::type> +{}; + +// All conversions from normalized types to float use the Normalize operator. +template <GLenum fromType> +struct ConversionRule<fromType, true, D3DVT_FLOAT> : Normalize<typename GLToCType<fromType>::type> +{}; + +// Use a full specialization for this so that it preferentially matches ahead of the generic +// normalize-to-float rules. +template <> +struct ConversionRule<GL_FIXED, true, D3DVT_FLOAT> : FixedToFloat<GLint, 16> +{}; +template <> +struct ConversionRule<GL_FIXED, false, D3DVT_FLOAT> : FixedToFloat<GLint, 16> +{}; + +// A 2-stage construction is used for DefaultVertexValues because float must use SimpleDefaultValues +// (i.e. 0/1) whether it is normalized or not. +template <class T, bool normalized> +struct DefaultVertexValuesStage2 +{}; + +template <class T> +struct DefaultVertexValuesStage2<T, true> : NormalizedDefaultValues<T> +{}; +template <class T> +struct DefaultVertexValuesStage2<T, false> : SimpleDefaultValues<T> +{}; + +// Work out the default value rule for a D3D type (expressed as the C type) and +template <class T, bool normalized> +struct DefaultVertexValues : DefaultVertexValuesStage2<T, normalized> +{}; +template <bool normalized> +struct DefaultVertexValues<float, normalized> : SimpleDefaultValues<float> +{}; + +// Policy rules for use with Converter, to choose whether to use the preferred or fallback +// conversion. The fallback conversion produces an output that all D3D9 devices must support. +template <class T> +struct UsePreferred +{ + enum + { + type = T::preferred + }; +}; +template <class T> +struct UseFallback +{ + enum + { + type = T::fallback + }; +}; + +// Converter ties it all together. Given an OpenGL type/norm/size and choice of preferred/fallback +// conversion, it provides all the members of the appropriate VertexDataConverter, the +// D3DCAPS9::DeclTypes flag in cap flag and the D3DDECLTYPE member needed for the vertex declaration +// in declflag. +template <GLenum fromType, bool normalized, int size, template <class T> class PreferenceRule> +struct Converter + : VertexDataConverter< + typename GLToCType<fromType>::type, + WidenRule<PreferenceRule<VertexTypeMapping<fromType, normalized>>::type, size>, + ConversionRule<fromType, + normalized, + PreferenceRule<VertexTypeMapping<fromType, normalized>>::type>, + DefaultVertexValues<typename D3DToCType<PreferenceRule< + VertexTypeMapping<fromType, normalized>>::type>::type, + normalized>> +{ + private: + enum + { + d3dtype = PreferenceRule<VertexTypeMapping<fromType, normalized>>::type + }; + enum + { + d3dsize = WidenRule<d3dtype, size>::finalWidth + }; + + public: + enum + { + capflag = VertexTypeFlags<d3dtype, d3dsize>::capflag + }; + enum + { + declflag = VertexTypeFlags<d3dtype, d3dsize>::declflag + }; +}; + +VertexFormat::VertexFormat() + : conversionType(VERTEX_CONVERT_NONE), + outputElementSize(0), + copyFunction(nullptr), + nativeFormat(D3DDECLTYPE_UNUSED), + componentType(GL_NONE) +{} + +// Initialize a TranslationInfo +VertexFormat CreateVertexFormatInfo(bool identity, + size_t elementSize, + VertexCopyFunction copyFunc, + D3DDECLTYPE nativeFormat) +{ + VertexFormat formatInfo; + formatInfo.conversionType = identity ? VERTEX_CONVERT_NONE : VERTEX_CONVERT_CPU; + formatInfo.outputElementSize = elementSize; + formatInfo.copyFunction = copyFunc; + formatInfo.nativeFormat = nativeFormat; + formatInfo.componentType = GetDeclTypeComponentType(nativeFormat); + return formatInfo; +} + +#define TRANSLATION(type, norm, size, preferred) \ + CreateVertexFormatInfo( \ + Converter<type, norm, size, preferred>::identity, \ + Converter<type, norm, size, preferred>::finalSize, \ + Converter<type, norm, size, preferred>::convertArray, \ + static_cast<D3DDECLTYPE>(Converter<type, norm, size, preferred>::declflag)) + +#define TRANSLATION_FOR_TYPE_NORM_SIZE(type, norm, size) \ + { \ + Converter<type, norm, size, UsePreferred>::capflag, \ + TRANSLATION(type, norm, size, UsePreferred), \ + TRANSLATION(type, norm, size, UseFallback) \ + } + +#define TRANSLATIONS_FOR_TYPE(type) \ + { \ + {TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4)}, \ + {TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 1), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 2), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 3), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 4)}, \ + } + +#define TRANSLATIONS_FOR_TYPE_NO_NORM(type) \ + { \ + {TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4)}, \ + {TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), \ + TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4)}, \ + } + +static inline unsigned int ComputeTypeIndex(GLenum type) +{ + switch (type) + { + case GL_BYTE: + return 0; + case GL_UNSIGNED_BYTE: + return 1; + case GL_SHORT: + return 2; + case GL_UNSIGNED_SHORT: + return 3; + case GL_FIXED: + return 4; + case GL_FLOAT: + return 5; + + default: + UNREACHABLE(); + return 5; + } +} + +const VertexFormat &GetVertexFormatInfo(DWORD supportedDeclTypes, angle::FormatID vertexFormatID) +{ + static DWORD initializedDeclTypes = 0; + static VertexFormat formatConverters[NUM_GL_VERTEX_ATTRIB_TYPES][2][4]; + if (initializedDeclTypes != supportedDeclTypes) + { + const TranslationDescription + translations[NUM_GL_VERTEX_ATTRIB_TYPES][2] + [4] = // [GL types as enumerated by typeIndex()][normalized][size-1] + {TRANSLATIONS_FOR_TYPE(GL_BYTE), TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_BYTE), + TRANSLATIONS_FOR_TYPE(GL_SHORT), TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_SHORT), + TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FIXED), TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FLOAT)}; + for (unsigned int i = 0; i < NUM_GL_VERTEX_ATTRIB_TYPES; i++) + { + for (unsigned int j = 0; j < 2; j++) + { + for (unsigned int k = 0; k < 4; k++) + { + if (translations[i][j][k].capsFlag == 0 || + (supportedDeclTypes & translations[i][j][k].capsFlag) != 0) + { + formatConverters[i][j][k] = translations[i][j][k].preferredConversion; + } + else + { + formatConverters[i][j][k] = translations[i][j][k].fallbackConversion; + } + } + } + } + initializedDeclTypes = supportedDeclTypes; + } + + const gl::VertexFormat &vertexFormat = gl::GetVertexFormatFromID(vertexFormatID); + + // Pure integer attributes only supported in ES3.0 + ASSERT(!vertexFormat.pureInteger); + return formatConverters[ComputeTypeIndex(vertexFormat.type)][vertexFormat.normalized] + [vertexFormat.components - 1]; +} +} // namespace d3d9 +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.h new file mode 100644 index 0000000000..c3997ec0e9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/formatutils9.h @@ -0,0 +1,59 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// formatutils9.h: Queries for GL image formats and their translations to D3D9 +// formats. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_FORMATUTILS9_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_FORMATUTILS9_H_ + +#include <map> + +#include "common/platform.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/Format.h" +#include "libANGLE/renderer/copyvertex.h" +#include "libANGLE/renderer/d3d/formatutilsD3D.h" +#include "libANGLE/renderer/d3d_format.h" +#include "libANGLE/renderer/renderer_utils.h" + +namespace rx +{ + +class Renderer9; + +namespace d3d9 +{ + +struct VertexFormat +{ + VertexFormat(); + + VertexConversionType conversionType; + size_t outputElementSize; + VertexCopyFunction copyFunction; + D3DDECLTYPE nativeFormat; + GLenum componentType; +}; +const VertexFormat &GetVertexFormatInfo(DWORD supportedDeclTypes, angle::FormatID vertexFormatID); + +struct TextureFormat +{ + TextureFormat(); + + D3DFORMAT texFormat; + D3DFORMAT renderFormat; + + InitializeTextureDataFunction dataInitializerFunction; + + LoadImageFunction loadFunction; +}; +const TextureFormat &GetTextureFormatInfo(GLenum internalFormat); +} // namespace d3d9 +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_FORMATUTILS9_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.cpp new file mode 100644 index 0000000000..79e5c9cb06 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.cpp @@ -0,0 +1,845 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// renderer9_utils.cpp: Conversion functions and other utility routines +// specific to the D3D9 renderer. + +#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" + +#include "common/debug.h" +#include "common/mathutil.h" + +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" +#include "libANGLE/renderer/d3d/d3d9/formatutils9.h" +#include "libANGLE/renderer/driver_utils.h" +#include "platform/FeaturesD3D_autogen.h" +#include "platform/PlatformMethods.h" + +#include "third_party/systeminfo/SystemInfo.h" + +namespace rx +{ + +namespace gl_d3d9 +{ + +D3DCMPFUNC ConvertComparison(GLenum comparison) +{ + D3DCMPFUNC d3dComp = D3DCMP_ALWAYS; + switch (comparison) + { + case GL_NEVER: + d3dComp = D3DCMP_NEVER; + break; + case GL_ALWAYS: + d3dComp = D3DCMP_ALWAYS; + break; + case GL_LESS: + d3dComp = D3DCMP_LESS; + break; + case GL_LEQUAL: + d3dComp = D3DCMP_LESSEQUAL; + break; + case GL_EQUAL: + d3dComp = D3DCMP_EQUAL; + break; + case GL_GREATER: + d3dComp = D3DCMP_GREATER; + break; + case GL_GEQUAL: + d3dComp = D3DCMP_GREATEREQUAL; + break; + case GL_NOTEQUAL: + d3dComp = D3DCMP_NOTEQUAL; + break; + default: + UNREACHABLE(); + } + + return d3dComp; +} + +D3DCOLOR ConvertColor(gl::ColorF color) +{ + return D3DCOLOR_RGBA(gl::unorm<8>(color.red), gl::unorm<8>(color.green), + gl::unorm<8>(color.blue), gl::unorm<8>(color.alpha)); +} + +D3DBLEND ConvertBlendFunc(GLenum blend) +{ + D3DBLEND d3dBlend = D3DBLEND_ZERO; + + switch (blend) + { + case GL_ZERO: + d3dBlend = D3DBLEND_ZERO; + break; + case GL_ONE: + d3dBlend = D3DBLEND_ONE; + break; + case GL_SRC_COLOR: + d3dBlend = D3DBLEND_SRCCOLOR; + break; + case GL_ONE_MINUS_SRC_COLOR: + d3dBlend = D3DBLEND_INVSRCCOLOR; + break; + case GL_DST_COLOR: + d3dBlend = D3DBLEND_DESTCOLOR; + break; + case GL_ONE_MINUS_DST_COLOR: + d3dBlend = D3DBLEND_INVDESTCOLOR; + break; + case GL_SRC_ALPHA: + d3dBlend = D3DBLEND_SRCALPHA; + break; + case GL_ONE_MINUS_SRC_ALPHA: + d3dBlend = D3DBLEND_INVSRCALPHA; + break; + case GL_DST_ALPHA: + d3dBlend = D3DBLEND_DESTALPHA; + break; + case GL_ONE_MINUS_DST_ALPHA: + d3dBlend = D3DBLEND_INVDESTALPHA; + break; + case GL_CONSTANT_COLOR: + d3dBlend = D3DBLEND_BLENDFACTOR; + break; + case GL_ONE_MINUS_CONSTANT_COLOR: + d3dBlend = D3DBLEND_INVBLENDFACTOR; + break; + case GL_CONSTANT_ALPHA: + d3dBlend = D3DBLEND_BLENDFACTOR; + break; + case GL_ONE_MINUS_CONSTANT_ALPHA: + d3dBlend = D3DBLEND_INVBLENDFACTOR; + break; + case GL_SRC_ALPHA_SATURATE: + d3dBlend = D3DBLEND_SRCALPHASAT; + break; + default: + UNREACHABLE(); + } + + return d3dBlend; +} + +D3DBLENDOP ConvertBlendOp(GLenum blendOp) +{ + D3DBLENDOP d3dBlendOp = D3DBLENDOP_ADD; + + switch (blendOp) + { + case GL_FUNC_ADD: + d3dBlendOp = D3DBLENDOP_ADD; + break; + case GL_FUNC_SUBTRACT: + d3dBlendOp = D3DBLENDOP_SUBTRACT; + break; + case GL_FUNC_REVERSE_SUBTRACT: + d3dBlendOp = D3DBLENDOP_REVSUBTRACT; + break; + case GL_MIN_EXT: + d3dBlendOp = D3DBLENDOP_MIN; + break; + case GL_MAX_EXT: + d3dBlendOp = D3DBLENDOP_MAX; + break; + default: + UNREACHABLE(); + } + + return d3dBlendOp; +} + +D3DSTENCILOP ConvertStencilOp(GLenum stencilOp) +{ + D3DSTENCILOP d3dStencilOp = D3DSTENCILOP_KEEP; + + switch (stencilOp) + { + case GL_ZERO: + d3dStencilOp = D3DSTENCILOP_ZERO; + break; + case GL_KEEP: + d3dStencilOp = D3DSTENCILOP_KEEP; + break; + case GL_REPLACE: + d3dStencilOp = D3DSTENCILOP_REPLACE; + break; + case GL_INCR: + d3dStencilOp = D3DSTENCILOP_INCRSAT; + break; + case GL_DECR: + d3dStencilOp = D3DSTENCILOP_DECRSAT; + break; + case GL_INVERT: + d3dStencilOp = D3DSTENCILOP_INVERT; + break; + case GL_INCR_WRAP: + d3dStencilOp = D3DSTENCILOP_INCR; + break; + case GL_DECR_WRAP: + d3dStencilOp = D3DSTENCILOP_DECR; + break; + default: + UNREACHABLE(); + } + + return d3dStencilOp; +} + +D3DTEXTUREADDRESS ConvertTextureWrap(GLenum wrap) +{ + D3DTEXTUREADDRESS d3dWrap = D3DTADDRESS_WRAP; + + switch (wrap) + { + case GL_REPEAT: + d3dWrap = D3DTADDRESS_WRAP; + break; + case GL_CLAMP_TO_EDGE: + d3dWrap = D3DTADDRESS_CLAMP; + break; + case GL_CLAMP_TO_BORDER: + d3dWrap = D3DTADDRESS_BORDER; + break; + case GL_MIRRORED_REPEAT: + d3dWrap = D3DTADDRESS_MIRROR; + break; + default: + UNREACHABLE(); + } + + return d3dWrap; +} + +D3DCULL ConvertCullMode(gl::CullFaceMode cullFace, GLenum frontFace) +{ + D3DCULL cull = D3DCULL_CCW; + switch (cullFace) + { + case gl::CullFaceMode::Front: + cull = (frontFace == GL_CCW ? D3DCULL_CW : D3DCULL_CCW); + break; + case gl::CullFaceMode::Back: + cull = (frontFace == GL_CCW ? D3DCULL_CCW : D3DCULL_CW); + break; + case gl::CullFaceMode::FrontAndBack: + cull = D3DCULL_NONE; // culling will be handled during draw + break; + default: + UNREACHABLE(); + } + + return cull; +} + +D3DCUBEMAP_FACES ConvertCubeFace(gl::TextureTarget cubeFace) +{ + D3DCUBEMAP_FACES face = D3DCUBEMAP_FACE_POSITIVE_X; + + switch (cubeFace) + { + case gl::TextureTarget::CubeMapPositiveX: + face = D3DCUBEMAP_FACE_POSITIVE_X; + break; + case gl::TextureTarget::CubeMapNegativeX: + face = D3DCUBEMAP_FACE_NEGATIVE_X; + break; + case gl::TextureTarget::CubeMapPositiveY: + face = D3DCUBEMAP_FACE_POSITIVE_Y; + break; + case gl::TextureTarget::CubeMapNegativeY: + face = D3DCUBEMAP_FACE_NEGATIVE_Y; + break; + case gl::TextureTarget::CubeMapPositiveZ: + face = D3DCUBEMAP_FACE_POSITIVE_Z; + break; + case gl::TextureTarget::CubeMapNegativeZ: + face = D3DCUBEMAP_FACE_NEGATIVE_Z; + break; + default: + UNREACHABLE(); + } + + return face; +} + +DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha) +{ + return (red ? D3DCOLORWRITEENABLE_RED : 0) | (green ? D3DCOLORWRITEENABLE_GREEN : 0) | + (blue ? D3DCOLORWRITEENABLE_BLUE : 0) | (alpha ? D3DCOLORWRITEENABLE_ALPHA : 0); +} + +D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy) +{ + if (maxAnisotropy > 1.0f) + { + return D3DTEXF_ANISOTROPIC; + } + + D3DTEXTUREFILTERTYPE d3dMagFilter = D3DTEXF_POINT; + switch (magFilter) + { + case GL_NEAREST: + d3dMagFilter = D3DTEXF_POINT; + break; + case GL_LINEAR: + d3dMagFilter = D3DTEXF_LINEAR; + break; + default: + UNREACHABLE(); + } + + return d3dMagFilter; +} + +void ConvertMinFilter(GLenum minFilter, + D3DTEXTUREFILTERTYPE *d3dMinFilter, + D3DTEXTUREFILTERTYPE *d3dMipFilter, + float *d3dLodBias, + float maxAnisotropy, + size_t baseLevel) +{ + switch (minFilter) + { + case GL_NEAREST: + *d3dMinFilter = D3DTEXF_POINT; + *d3dMipFilter = D3DTEXF_NONE; + break; + case GL_LINEAR: + *d3dMinFilter = D3DTEXF_LINEAR; + *d3dMipFilter = D3DTEXF_NONE; + break; + case GL_NEAREST_MIPMAP_NEAREST: + *d3dMinFilter = D3DTEXF_POINT; + *d3dMipFilter = D3DTEXF_POINT; + break; + case GL_LINEAR_MIPMAP_NEAREST: + *d3dMinFilter = D3DTEXF_LINEAR; + *d3dMipFilter = D3DTEXF_POINT; + break; + case GL_NEAREST_MIPMAP_LINEAR: + *d3dMinFilter = D3DTEXF_POINT; + *d3dMipFilter = D3DTEXF_LINEAR; + break; + case GL_LINEAR_MIPMAP_LINEAR: + *d3dMinFilter = D3DTEXF_LINEAR; + *d3dMipFilter = D3DTEXF_LINEAR; + break; + default: + *d3dMinFilter = D3DTEXF_POINT; + *d3dMipFilter = D3DTEXF_NONE; + UNREACHABLE(); + } + + // Disabling mipmapping will always sample from level 0 of the texture. It is possible to work + // around this by modifying D3DSAMP_MAXMIPLEVEL to force a specific mip level to become the + // lowest sampled mip level and using a large negative value for D3DSAMP_MIPMAPLODBIAS to + // ensure that only the base mip level is sampled. + if (baseLevel > 0 && *d3dMipFilter == D3DTEXF_NONE) + { + *d3dMipFilter = D3DTEXF_POINT; + *d3dLodBias = -static_cast<float>(gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); + } + else + { + *d3dLodBias = 0.0f; + } + + if (maxAnisotropy > 1.0f) + { + *d3dMinFilter = D3DTEXF_ANISOTROPIC; + } +} + +D3DQUERYTYPE ConvertQueryType(gl::QueryType type) +{ + switch (type) + { + case gl::QueryType::AnySamples: + case gl::QueryType::AnySamplesConservative: + return D3DQUERYTYPE_OCCLUSION; + case gl::QueryType::CommandsCompleted: + return D3DQUERYTYPE_EVENT; + default: + UNREACHABLE(); + return static_cast<D3DQUERYTYPE>(0); + } +} + +D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples) +{ + return (samples > 1) ? static_cast<D3DMULTISAMPLE_TYPE>(samples) : D3DMULTISAMPLE_NONE; +} + +} // namespace gl_d3d9 + +namespace d3d9_gl +{ + +unsigned int GetReservedVaryingVectors() +{ + // We reserve two registers for "dx_Position" and "gl_Position". The spec says they + // don't count towards the varying limit, so we must make space for them. We also + // reserve the last register since it can only pass a PSIZE, and not any arbitrary + // varying. + return 3; +} + +unsigned int GetReservedVertexUniformVectors() +{ + return 3; // dx_ViewCoords, dx_ViewAdjust and dx_DepthRange. +} + +unsigned int GetReservedFragmentUniformVectors() +{ + return 4; // dx_ViewCoords, dx_DepthFront, dx_DepthRange, dx_FragCoordoffset. +} + +GLsizei GetSamplesCount(D3DMULTISAMPLE_TYPE type) +{ + return (type != D3DMULTISAMPLE_NONMASKABLE) ? type : 0; +} + +bool IsFormatChannelEquivalent(D3DFORMAT d3dformat, GLenum format) +{ + GLenum internalFormat = d3d9::GetD3DFormatInfo(d3dformat).info().glInternalFormat; + GLenum convertedFormat = gl::GetSizedInternalFormatInfo(internalFormat).format; + return convertedFormat == format; +} + +static gl::TextureCaps GenerateTextureFormatCaps(GLenum internalFormat, + IDirect3D9 *d3d9, + D3DDEVTYPE deviceType, + UINT adapter, + D3DFORMAT adapterFormat) +{ + gl::TextureCaps textureCaps; + + const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalFormat); + const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalFormat); + + if (d3dFormatInfo.texFormat != D3DFMT_UNKNOWN) + { + if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) + { + textureCaps.texturable = SUCCEEDED(d3d9->CheckDeviceFormat( + adapter, deviceType, adapterFormat, 0, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)); + } + else + { + textureCaps.texturable = + SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, + D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)) && + SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, + D3DRTYPE_CUBETEXTURE, d3dFormatInfo.texFormat)); + if (textureCaps.texturable && (formatInfo.colorEncoding == GL_SRGB)) + { + textureCaps.texturable = + SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, + D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_TEXTURE, + d3dFormatInfo.texFormat)) && + SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, + D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_CUBETEXTURE, + d3dFormatInfo.texFormat)); + } + } + + textureCaps.filterable = SUCCEEDED( + d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_QUERY_FILTER, + D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)); + } + + if (d3dFormatInfo.renderFormat != D3DFMT_UNKNOWN) + { + textureCaps.textureAttachment = SUCCEEDED( + d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_RENDERTARGET, + D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat)); + if (textureCaps.textureAttachment && (formatInfo.colorEncoding == GL_SRGB)) + { + textureCaps.textureAttachment = SUCCEEDED(d3d9->CheckDeviceFormat( + adapter, deviceType, adapterFormat, D3DUSAGE_QUERY_SRGBWRITE, D3DRTYPE_TEXTURE, + d3dFormatInfo.renderFormat)); + } + + if ((formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) && + !textureCaps.textureAttachment) + { + textureCaps.textureAttachment = SUCCEEDED( + d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_DEPTHSTENCIL, + D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat)); + } + textureCaps.renderbuffer = textureCaps.textureAttachment; + textureCaps.blendable = textureCaps.renderbuffer; + + textureCaps.sampleCounts.insert(1); + for (unsigned int i = D3DMULTISAMPLE_2_SAMPLES; i <= D3DMULTISAMPLE_16_SAMPLES; i++) + { + D3DMULTISAMPLE_TYPE multisampleType = D3DMULTISAMPLE_TYPE(i); + + HRESULT result = d3d9->CheckDeviceMultiSampleType( + adapter, deviceType, d3dFormatInfo.renderFormat, TRUE, multisampleType, nullptr); + if (SUCCEEDED(result)) + { + textureCaps.sampleCounts.insert(i); + } + } + } + + return textureCaps; +} + +void GenerateCaps(IDirect3D9 *d3d9, + IDirect3DDevice9 *device, + D3DDEVTYPE deviceType, + UINT adapter, + gl::Caps *caps, + gl::TextureCapsMap *textureCapsMap, + gl::Extensions *extensions, + gl::Limitations *limitations) +{ + D3DCAPS9 deviceCaps; + if (FAILED(d3d9->GetDeviceCaps(adapter, deviceType, &deviceCaps))) + { + // Can't continue with out device caps + return; + } + + D3DDISPLAYMODE currentDisplayMode; + d3d9->GetAdapterDisplayMode(adapter, ¤tDisplayMode); + + GLuint maxSamples = 0; + for (GLenum internalFormat : gl::GetAllSizedInternalFormats()) + { + gl::TextureCaps textureCaps = GenerateTextureFormatCaps(internalFormat, d3d9, deviceType, + adapter, currentDisplayMode.Format); + textureCapsMap->insert(internalFormat, textureCaps); + + maxSamples = std::max(maxSamples, textureCaps.getMaxSamples()); + } + + // GL core feature limits + caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max()); + + // 3D textures are unimplemented in D3D9 + caps->max3DTextureSize = 1; + + // Only one limit in GL, use the minimum dimension + caps->max2DTextureSize = std::min(deviceCaps.MaxTextureWidth, deviceCaps.MaxTextureHeight); + + // D3D treats cube maps as a special case of 2D textures + caps->maxCubeMapTextureSize = caps->max2DTextureSize; + + // Array textures are not available in D3D9 + caps->maxArrayTextureLayers = 1; + + // ES3-only feature + caps->maxLODBias = 0.0f; + + // No specific limits on render target size, maximum 2D texture size is equivalent + caps->maxRenderbufferSize = caps->max2DTextureSize; + + // Draw buffers are not supported in D3D9 + caps->maxDrawBuffers = 1; + caps->maxColorAttachments = 1; + + // No specific limits on viewport size, maximum 2D texture size is equivalent + caps->maxViewportWidth = caps->max2DTextureSize; + caps->maxViewportHeight = caps->maxViewportWidth; + + // Point size is clamped to 1.0f when the shader model is less than 3 + caps->minAliasedPointSize = 1.0f; + caps->maxAliasedPointSize = + ((D3DSHADER_VERSION_MAJOR(deviceCaps.PixelShaderVersion) >= 3) ? deviceCaps.MaxPointSize + : 1.0f); + + // Wide lines not supported + caps->minAliasedLineWidth = 1.0f; + caps->maxAliasedLineWidth = 1.0f; + + // Primitive count limits (unused in ES2) + caps->maxElementsIndices = 0; + caps->maxElementsVertices = 0; + + // Program and shader binary formats (no supported shader binary formats) + caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE); + + caps->vertexHighpFloat.setIEEEFloat(); + caps->vertexMediumpFloat.setIEEEFloat(); + caps->vertexLowpFloat.setIEEEFloat(); + caps->fragmentHighpFloat.setIEEEFloat(); + caps->fragmentMediumpFloat.setIEEEFloat(); + caps->fragmentLowpFloat.setIEEEFloat(); + + // Some (most) hardware only supports single-precision floating-point numbers, + // which can accurately represent integers up to +/-16777216 + caps->vertexHighpInt.setSimulatedInt(24); + caps->vertexMediumpInt.setSimulatedInt(24); + caps->vertexLowpInt.setSimulatedInt(24); + caps->fragmentHighpInt.setSimulatedInt(24); + caps->fragmentMediumpInt.setSimulatedInt(24); + caps->fragmentLowpInt.setSimulatedInt(24); + + // WaitSync is ES3-only, set to zero + caps->maxServerWaitTimeout = 0; + + // Vertex shader limits + caps->maxVertexAttributes = 16; + // Vertex Attrib Binding not supported. + caps->maxVertexAttribBindings = caps->maxVertexAttributes; + + const size_t MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256; + caps->maxVertexUniformVectors = + MAX_VERTEX_CONSTANT_VECTORS_D3D9 - GetReservedVertexUniformVectors(); + caps->maxShaderUniformComponents[gl::ShaderType::Vertex] = caps->maxVertexUniformVectors * 4; + + caps->maxShaderUniformBlocks[gl::ShaderType::Vertex] = 0; + + // SM3 only supports 12 output variables, but the special 12th register is only for PSIZE. + const unsigned int MAX_VERTEX_OUTPUT_VECTORS_SM3 = 12 - GetReservedVaryingVectors(); + const unsigned int MAX_VERTEX_OUTPUT_VECTORS_SM2 = 10 - GetReservedVaryingVectors(); + caps->maxVertexOutputComponents = + ((deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) ? MAX_VERTEX_OUTPUT_VECTORS_SM3 + : MAX_VERTEX_OUTPUT_VECTORS_SM2) * + 4; + + // Only Direct3D 10 ready devices support all the necessary vertex texture formats. + // We test this using D3D9 by checking support for the R16F format. + if (deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0) && + SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, currentDisplayMode.Format, + D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, + D3DFMT_R16F))) + { + const size_t MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4; + caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] = MAX_TEXTURE_IMAGE_UNITS_VTF_SM3; + } + else + { + caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] = 0; + } + + // Fragment shader limits + const size_t MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224; + const size_t MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32; + caps->maxFragmentUniformVectors = + ((deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) ? MAX_PIXEL_CONSTANT_VECTORS_SM3 + : MAX_PIXEL_CONSTANT_VECTORS_SM2) - + GetReservedFragmentUniformVectors(); + caps->maxShaderUniformComponents[gl::ShaderType::Fragment] = + caps->maxFragmentUniformVectors * 4; + caps->maxShaderUniformBlocks[gl::ShaderType::Fragment] = 0; + caps->maxFragmentInputComponents = caps->maxVertexOutputComponents; + caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment] = 16; + caps->minProgramTexelOffset = 0; + caps->maxProgramTexelOffset = 0; + + // Aggregate shader limits (unused in ES2) + caps->maxUniformBufferBindings = 0; + caps->maxUniformBlockSize = 0; + caps->uniformBufferOffsetAlignment = 0; + caps->maxCombinedUniformBlocks = 0; + caps->maxCombinedShaderUniformComponents[gl::ShaderType::Vertex] = 0; + caps->maxCombinedShaderUniformComponents[gl::ShaderType::Fragment] = 0; + caps->maxVaryingComponents = 0; + + // Aggregate shader limits + caps->maxVaryingVectors = caps->maxVertexOutputComponents / 4; + caps->maxCombinedTextureImageUnits = caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] + + caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment]; + + // Transform feedback limits + caps->maxTransformFeedbackInterleavedComponents = 0; + caps->maxTransformFeedbackSeparateAttributes = 0; + caps->maxTransformFeedbackSeparateComponents = 0; + + // Multisample limits + caps->maxSamples = maxSamples; + + // GL extension support + extensions->setTextureExtensionSupport(*textureCapsMap); + extensions->elementIndexUintOES = deviceCaps.MaxVertexIndex >= (1 << 16); + extensions->getProgramBinaryOES = true; + extensions->rgb8Rgba8OES = true; + extensions->readFormatBgraEXT = true; + extensions->pixelBufferObjectNV = false; + extensions->mapbufferOES = false; + extensions->mapBufferRangeEXT = false; + + // D3D does not allow depth textures to have more than one mipmap level OES_depth_texture + // allows for that so we can't implement full support with the D3D9 back end. + extensions->depthTextureOES = false; + + // textureRgEXT is emulated and not performant. + extensions->textureRgEXT = false; + + // GL_KHR_parallel_shader_compile + extensions->parallelShaderCompileKHR = true; + + D3DADAPTER_IDENTIFIER9 adapterId = {}; + if (SUCCEEDED(d3d9->GetAdapterIdentifier(adapter, 0, &adapterId))) + { + // ATI cards on XP have problems with non-power-of-two textures. + extensions->textureNpotOES = + !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_POW2) && + !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) && + !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) && + !(!isWindowsVistaOrGreater() && IsAMD(adapterId.VendorId)); + + // Disable depth texture support on AMD cards (See ANGLE issue 839) + if (IsAMD(adapterId.VendorId)) + { + extensions->depthTextureANGLE = false; + extensions->depthTextureOES = false; + } + } + else + { + extensions->textureNpotOES = false; + } + + extensions->drawBuffersEXT = false; + extensions->textureStorageEXT = true; + + // Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per + // the spec + extensions->textureFilterAnisotropicEXT = + (deviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) != 0 && deviceCaps.MaxAnisotropy >= 2; + caps->maxTextureAnisotropy = static_cast<GLfloat>(deviceCaps.MaxAnisotropy); + + // Check occlusion query support by trying to create one + IDirect3DQuery9 *occlusionQuery = nullptr; + extensions->occlusionQueryBooleanEXT = + SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery)) && occlusionQuery; + SafeRelease(occlusionQuery); + + // Check event query support by trying to create one + IDirect3DQuery9 *eventQuery = nullptr; + extensions->fenceNV = + SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_EVENT, &eventQuery)) && eventQuery; + SafeRelease(eventQuery); + + extensions->disjointTimerQueryEXT = false; + extensions->robustnessEXT = true; + // It seems that only DirectX 10 and higher enforce the well-defined behavior of always + // returning zero values when out-of-bounds reads. See + // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_robustness.txt + extensions->robustBufferAccessBehaviorKHR = false; + extensions->blendMinmaxEXT = true; + // Although according to + // https://docs.microsoft.com/en-us/windows/desktop/direct3ddxgi/format-support-for-direct3d-feature-level-9-1-hardware + // D3D9 doesn't have full blending capability for RGBA32F. But turns out it could provide + // correct blending result in reality. As a result of some regression reports by client app, we + // decided to turn floatBlendEXT on for D3D9 + extensions->floatBlendEXT = true; + extensions->framebufferBlitANGLE = true; + extensions->framebufferMultisampleANGLE = true; + extensions->instancedArraysANGLE = deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0); + // D3D9 requires at least one attribute that has a divisor of 0, which isn't required by the EXT + // extension + extensions->instancedArraysEXT = false; + extensions->packReverseRowOrderANGLE = true; + extensions->standardDerivativesOES = + (deviceCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) != 0; + extensions->shaderTextureLodEXT = true; + extensions->fragDepthEXT = true; + extensions->textureUsageANGLE = true; + extensions->translatedShaderSourceANGLE = true; + extensions->fboRenderMipmapOES = true; + extensions->discardFramebufferEXT = false; // It would be valid to set this to true, since + // glDiscardFramebufferEXT is just a hint + extensions->colorBufferFloatEXT = false; + extensions->debugMarkerEXT = true; + extensions->EGLImageOES = true; + extensions->EGLImageExternalOES = true; + extensions->unpackSubimageEXT = true; + extensions->packSubimageNV = true; + extensions->syncQueryCHROMIUM = extensions->fenceNV; + extensions->copyTextureCHROMIUM = true; + extensions->textureBorderClampOES = true; + extensions->videoTextureWEBGL = true; + + // D3D9 has no concept of separate masks and refs for front and back faces in the depth stencil + // state. + limitations->noSeparateStencilRefsAndMasks = true; + + // D3D9 shader models have limited support for looping, so the Appendix A + // index/loop limitations are necessary. Workarounds that are needed to + // support dynamic indexing of vectors on HLSL also don't work on D3D9. + limitations->shadersRequireIndexedLoopValidation = true; + + // D3D9 cannot support constant color and alpha blend funcs together + limitations->noSimultaneousConstantColorAndAlphaBlendFunc = true; + + // D3D9 cannot support unclamped constant blend color + limitations->noUnclampedBlendColor = true; + + // D3D9 cannot support packing more than one variable to a single varying. + // TODO(jmadill): Implement more sophisticated component packing in D3D9. + limitations->noFlexibleVaryingPacking = true; + + // D3D9 does not support vertex attribute aliasing + limitations->noVertexAttributeAliasing = true; + + // D3D9 does not support compressed textures where the base mip level is not a multiple of 4 + limitations->compressedBaseMipLevelMultipleOfFour = true; +} + +} // namespace d3d9_gl + +namespace d3d9 +{ + +GLuint ComputeBlockSize(D3DFORMAT format, GLuint width, GLuint height) +{ + const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format); + GLuint numBlocksWide = (width + d3dFormatInfo.blockWidth - 1) / d3dFormatInfo.blockWidth; + GLuint numBlocksHight = (height + d3dFormatInfo.blockHeight - 1) / d3dFormatInfo.blockHeight; + return (d3dFormatInfo.pixelBytes * numBlocksWide * numBlocksHight); +} + +void MakeValidSize(bool isImage, + D3DFORMAT format, + GLsizei *requestWidth, + GLsizei *requestHeight, + int *levelOffset) +{ + const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format); + + int upsampleCount = 0; + // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already. + if (isImage || *requestWidth < static_cast<GLsizei>(d3dFormatInfo.blockWidth) || + *requestHeight < static_cast<GLsizei>(d3dFormatInfo.blockHeight)) + { + while (*requestWidth % d3dFormatInfo.blockWidth != 0 || + *requestHeight % d3dFormatInfo.blockHeight != 0) + { + *requestWidth <<= 1; + *requestHeight <<= 1; + upsampleCount++; + } + } + *levelOffset = upsampleCount; +} + +void InitializeFeatures(angle::FeaturesD3D *features) +{ + ANGLE_FEATURE_CONDITION(features, mrtPerfWorkaround, true); + ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUpload, false); + ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUploadOn128bitFormats, false); + ANGLE_FEATURE_CONDITION(features, useInstancedPointSpriteEmulation, false); + + // TODO(jmadill): Disable workaround when we have a fixed compiler DLL. + ANGLE_FEATURE_CONDITION(features, expandIntegerPowExpressions, true); + + // crbug.com/1011627 Turn this on for D3D9. + ANGLE_FEATURE_CONDITION(features, allowClearForRobustResourceInit, true); +} + +} // namespace d3d9 + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.h new file mode 100644 index 0000000000..b900e9c44c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/renderer9_utils.h @@ -0,0 +1,105 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// renderer9_utils.h: Conversion functions and other utility routines +// specific to the D3D9 renderer + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_RENDERER9UTILS_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_RENDERER9UTILS_H_ + +#include "common/Color.h" +#include "libANGLE/Caps.h" +#include "libANGLE/Error.h" +#include "platform/FeaturesD3D_autogen.h" + +namespace gl +{ +class FramebufferAttachment; +} + +namespace rx +{ +class RenderTarget9; + +namespace gl_d3d9 +{ + +D3DCMPFUNC ConvertComparison(GLenum comparison); +D3DCOLOR ConvertColor(gl::ColorF color); +D3DBLEND ConvertBlendFunc(GLenum blend); +D3DBLENDOP ConvertBlendOp(GLenum blendOp); +D3DSTENCILOP ConvertStencilOp(GLenum stencilOp); +D3DTEXTUREADDRESS ConvertTextureWrap(GLenum wrap); +D3DCULL ConvertCullMode(gl::CullFaceMode cullFace, GLenum frontFace); +D3DCUBEMAP_FACES ConvertCubeFace(gl::TextureTarget cubeFace); +DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha); +D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy); +void ConvertMinFilter(GLenum minFilter, + D3DTEXTUREFILTERTYPE *d3dMinFilter, + D3DTEXTUREFILTERTYPE *d3dMipFilter, + float *d3dLodBias, + float maxAnisotropy, + size_t baseLevel); +D3DQUERYTYPE ConvertQueryType(gl::QueryType type); + +D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples); + +} // namespace gl_d3d9 + +namespace d3d9_gl +{ + +unsigned int GetReservedVaryingVectors(); + +unsigned int GetReservedVertexUniformVectors(); + +unsigned int GetReservedFragmentUniformVectors(); + +GLsizei GetSamplesCount(D3DMULTISAMPLE_TYPE type); + +bool IsFormatChannelEquivalent(D3DFORMAT d3dformat, GLenum format); + +void GenerateCaps(IDirect3D9 *d3d9, + IDirect3DDevice9 *device, + D3DDEVTYPE deviceType, + UINT adapter, + gl::Caps *caps, + gl::TextureCapsMap *textureCapsMap, + gl::Extensions *extensions, + gl::Limitations *limitations); +} // namespace d3d9_gl + +namespace d3d9 +{ + +GLuint ComputeBlockSize(D3DFORMAT format, GLuint width, GLuint height); + +void MakeValidSize(bool isImage, + D3DFORMAT format, + GLsizei *requestWidth, + GLsizei *requestHeight, + int *levelOffset); + +inline bool isDeviceLostError(HRESULT errorCode) +{ + switch (errorCode) + { + case D3DERR_DRIVERINTERNALERROR: + case D3DERR_DEVICELOST: + case D3DERR_DEVICEHUNG: + case D3DERR_DEVICEREMOVED: + return true; + default: + return false; + } +} + +void InitializeFeatures(angle::FeaturesD3D *features); +} // namespace d3d9 + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_RENDERER9UTILS_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskpremultps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskpremultps.h new file mode 100644 index 0000000000..04868aeb9c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskpremultps.h @@ -0,0 +1,50 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mul r0.xyz, r0.w, r0 + mov r1, c0 + mad r0, r0, r1, c1 + mov oC0, r0 + +// approximately 5 instruction slots used (1 texture, 4 arithmetic) +#endif + +const BYTE g_ps20_componentmaskpremultps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 5, 0, 0, 3, 0, 0, 7, 128, 0, 0, 255, 128, 0, 0, 228, 128, 1, 0, + 0, 2, 1, 0, 15, 128, 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, + 0, 228, 128, 1, 0, 228, 128, 1, 0, 228, 160, 1, 0, 0, 2, 0, 8, 15, 128, + 0, 0, 228, 128, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskps.h new file mode 100644 index 0000000000..06673ae5f7 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskps.h @@ -0,0 +1,48 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mov r1, c0 + mad r0, r0, r1, c1 + mov oC0, r0 + +// approximately 4 instruction slots used (1 texture, 3 arithmetic) +#endif + +const BYTE g_ps20_componentmaskps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 1, 0, 0, 2, 1, 0, 15, 128, 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, + 15, 128, 0, 0, 228, 128, 1, 0, 228, 128, 1, 0, 228, 160, 1, 0, 0, 2, 0, + 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskunmultps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskunmultps.h new file mode 100644 index 0000000000..ad15364bb8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/componentmaskunmultps.h @@ -0,0 +1,54 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + rcp r1.w, r0.w + mul r1.xyz, r0, r1.w + cmp r0.xyz, -r0.w, r0, r1 + mov r1, c0 + mad r0, r0, r1, c1 + mov oC0, r0 + +// approximately 7 instruction slots used (1 texture, 6 arithmetic) +#endif + +const BYTE g_ps20_componentmaskunmultps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 6, 0, 0, 2, 1, 0, 8, 128, 0, 0, 255, 128, 5, 0, 0, 3, 1, 0, + 7, 128, 0, 0, 228, 128, 1, 0, 255, 128, 88, 0, 0, 4, 0, 0, 7, 128, 0, + 0, 255, 129, 0, 0, 228, 128, 1, 0, 228, 128, 1, 0, 0, 2, 1, 0, 15, 128, + 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 228, 128, 1, 0, 228, + 128, 1, 0, 228, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, + 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminancepremultps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminancepremultps.h new file mode 100644 index 0000000000..274a7824f9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminancepremultps.h @@ -0,0 +1,50 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mul r0.xyz, r0.w, r0.x + mov r1, c0 + mad r0, r0, r1, c1 + mov oC0, r0 + +// approximately 5 instruction slots used (1 texture, 4 arithmetic) +#endif + +const BYTE g_ps20_luminancepremultps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 5, 0, 0, 3, 0, 0, 7, 128, 0, 0, 255, 128, 0, 0, 0, 128, 1, 0, + 0, 2, 1, 0, 15, 128, 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, + 0, 228, 128, 1, 0, 228, 128, 1, 0, 228, 160, 1, 0, 0, 2, 0, 8, 15, 128, + 0, 0, 228, 128, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceps.h new file mode 100644 index 0000000000..0be665c525 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceps.h @@ -0,0 +1,53 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mov r1.xw, c0 + mad r0.x, r0.x, r1.x, c1.x + mad r0.y, r0.w, r1.w, c1.w + mov r1.xyz, r0.x + mov r1.w, r0.y + mov oC0, r1 + +// approximately 7 instruction slots used (1 texture, 6 arithmetic) +#endif + +const BYTE g_ps20_luminanceps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 1, 0, 0, 2, 1, 0, 9, 128, 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, + 1, 128, 0, 0, 0, 128, 1, 0, 0, 128, 1, 0, 0, 160, 4, 0, 0, 4, 0, + 0, 2, 128, 0, 0, 255, 128, 1, 0, 255, 128, 1, 0, 255, 160, 1, 0, 0, 2, + 1, 0, 7, 128, 0, 0, 0, 128, 1, 0, 0, 2, 1, 0, 8, 128, 0, 0, 85, + 128, 1, 0, 0, 2, 0, 8, 15, 128, 1, 0, 228, 128, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceunmultps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceunmultps.h new file mode 100644 index 0000000000..1100d0b088 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceunmultps.h @@ -0,0 +1,54 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 add; +// float4 mult; +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// mult c0 1 +// add c1 1 +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + rcp r1.w, r0.w + mul r1.x, r0.x, r1.w + cmp r0.xyz, -r0.w, r0.x, r1.x + mov r1, c0 + mad r0, r0, r1, c1 + mov oC0, r0 + +// approximately 7 instruction slots used (1 texture, 6 arithmetic) +#endif + +const BYTE g_ps20_luminanceunmultps[] = { + 0, 2, 255, 255, 254, 255, 50, 0, 67, 84, 65, 66, 28, 0, 0, 0, 143, 0, 0, + 0, 0, 2, 255, 255, 3, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 136, 0, + 0, 0, 88, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 92, 0, 0, 0, 0, + 0, 0, 0, 108, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 92, 0, 0, 0, + 0, 0, 0, 0, 113, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 120, 0, 0, + 0, 0, 0, 0, 0, 97, 100, 100, 0, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 109, 117, 108, 116, 0, 116, 101, 120, 0, 171, 171, 171, 4, + 0, 12, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, + 95, 48, 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, + 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, + 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, + 0, 8, 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, + 160, 6, 0, 0, 2, 1, 0, 8, 128, 0, 0, 255, 128, 5, 0, 0, 3, 1, 0, + 1, 128, 0, 0, 0, 128, 1, 0, 255, 128, 88, 0, 0, 4, 0, 0, 7, 128, 0, + 0, 255, 129, 0, 0, 0, 128, 1, 0, 0, 128, 1, 0, 0, 2, 1, 0, 15, 128, + 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 228, 128, 1, 0, 228, + 128, 1, 0, 228, 160, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, + 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/passthroughps.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/passthroughps.h new file mode 100644 index 0000000000..0c17739e17 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/passthroughps.h @@ -0,0 +1,37 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// sampler2D tex; +// +// +// Registers: +// +// Name Reg Size +// ------------ ----- ---- +// tex s0 1 +// + + ps_2_0 + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mov oC0, r0 + +// approximately 2 instruction slots used (1 texture, 1 arithmetic) +#endif + +const BYTE g_ps20_passthroughps[] = { + 0, 2, 255, 255, 254, 255, 33, 0, 67, 84, 65, 66, 28, 0, 0, 0, 75, 0, + 0, 0, 0, 2, 255, 255, 1, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, + 68, 0, 0, 0, 48, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 52, 0, + 0, 0, 0, 0, 0, 0, 116, 101, 120, 0, 4, 0, 12, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 112, 115, 95, 50, 95, 48, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, + 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, + 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 171, 171, 31, 0, 0, 2, + 0, 0, 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, + 15, 160, 66, 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, + 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/standardvs.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/standardvs.h new file mode 100644 index 0000000000..e4d7e0e1a8 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/shaders/compiled/standardvs.h @@ -0,0 +1,46 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// Parameters: +// +// float4 halfPixelSize; +// float4 texcoordOffset; +// +// +// Registers: +// +// Name Reg Size +// -------------- ----- ---- +// halfPixelSize c0 1 +// texcoordOffset c1 1 +// + + vs_2_0 + def c2, 0.5, -0.5, 1, 0 + dcl_position v0 + add oPos, v0, c0 + mad r0, v0, c2.xyzz, c2.xxww + mov oT0.zw, r0 + mad oT0.xy, r0, c1.zwzw, c1 + +// approximately 4 instruction slots used +#endif + +const BYTE g_vs20_standardvs[] = { + 0, 2, 254, 255, 254, 255, 44, 0, 67, 84, 65, 66, 28, 0, 0, 0, 122, 0, 0, + 0, 0, 2, 254, 255, 2, 0, 0, 0, 28, 0, 0, 0, 0, 1, 0, 0, 115, 0, + 0, 0, 68, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 0, + 0, 0, 0, 100, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 84, 0, 0, 0, + 0, 0, 0, 0, 104, 97, 108, 102, 80, 105, 120, 101, 108, 83, 105, 122, 101, 0, 171, + 171, 1, 0, 3, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 116, 101, + 120, 99, 111, 111, 114, 100, 79, 102, 102, 115, 101, 116, 0, 118, 115, 95, 50, 95, 48, + 0, 77, 105, 99, 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, + 32, 83, 104, 97, 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, + 51, 46, 57, 54, 48, 48, 46, 49, 54, 51, 56, 52, 0, 81, 0, 0, 5, 2, 0, + 15, 160, 0, 0, 0, 63, 0, 0, 0, 191, 0, 0, 128, 63, 0, 0, 0, 0, 31, + 0, 0, 2, 0, 0, 0, 128, 0, 0, 15, 144, 2, 0, 0, 3, 0, 0, 15, 192, + 0, 0, 228, 144, 0, 0, 228, 160, 4, 0, 0, 4, 0, 0, 15, 128, 0, 0, 228, + 144, 2, 0, 164, 160, 2, 0, 240, 160, 1, 0, 0, 2, 0, 0, 12, 224, 0, 0, + 228, 128, 4, 0, 0, 4, 0, 0, 3, 224, 0, 0, 228, 128, 1, 0, 238, 160, 1, + 0, 228, 160, 255, 255, 0, 0}; diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/vertexconversion.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/vertexconversion.h new file mode 100644 index 0000000000..fb172448d1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/d3d9/vertexconversion.h @@ -0,0 +1,197 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// vertexconversion.h: A library of vertex conversion classes that can be used to build +// the FormatConverter objects used by the buffer conversion system. + +#ifndef LIBANGLE_RENDERER_D3D_D3D9_VERTEXCONVERSION_H_ +#define LIBANGLE_RENDERER_D3D_D3D9_VERTEXCONVERSION_H_ + +#include <cstddef> +#include <cstdint> +#include <limits> + +namespace rx +{ + +// Conversion types: +// static const bool identity: true if this is an identity transform, false otherwise +// static U convert(T): convert a single element from the input type to the output type +// typedef ... OutputType: the type produced by this conversion + +template <class T> +struct Identity +{ + static const bool identity = true; + + typedef T OutputType; + + static T convert(T x) { return x; } +}; + +template <class FromT, class ToT> +struct Cast +{ + static const bool identity = false; + + typedef ToT OutputType; + + static ToT convert(FromT x) { return static_cast<ToT>(x); } +}; + +template <class T> +struct Cast<T, T> +{ + static const bool identity = true; + + typedef T OutputType; + + static T convert(T x) { return static_cast<T>(x); } +}; + +template <class T> +struct Normalize +{ + static const bool identity = false; + + typedef float OutputType; + + static float convert(T x) + { + typedef std::numeric_limits<T> NL; + float f = static_cast<float>(x); + + if (NL::is_signed) + { + // const float => VC2008 computes it at compile time + // static const float => VC2008 computes it the first time we get here, stores it to + // memory with static guard and all that. + const float divisor = 1.0f / (2 * static_cast<float>(NL::max()) + 1); + return (2 * f + 1) * divisor; + } + else + { + return f / NL::max(); + } + } +}; + +template <class FromType, std::size_t ScaleBits> +struct FixedToFloat +{ + static const bool identity = false; + + typedef float OutputType; + + static float convert(FromType x) + { + const float divisor = 1.0f / static_cast<float>(static_cast<FromType>(1) << ScaleBits); + return static_cast<float>(x) * divisor; + } +}; + +// Widen types: +// static const unsigned int initialWidth: number of components before conversion +// static const unsigned int finalWidth: number of components after conversion + +// Float is supported at any size. +template <std::size_t N> +struct NoWiden +{ + static const std::size_t initialWidth = N; + static const std::size_t finalWidth = N; +}; + +// SHORT, norm-SHORT, norm-UNSIGNED_SHORT are supported but only with 2 or 4 components +template <std::size_t N> +struct WidenToEven +{ + static const std::size_t initialWidth = N; + static const std::size_t finalWidth = N + (N & 1); +}; + +template <std::size_t N> +struct WidenToFour +{ + static const std::size_t initialWidth = N; + static const std::size_t finalWidth = 4; +}; + +// Most types have 0 and 1 that are just that. +template <class T> +struct SimpleDefaultValues +{ + static T zero() { return static_cast<T>(0); } + static T one() { return static_cast<T>(1); } +}; + +// But normalised types only store [0,1] or [-1,1] so 1.0 is represented by the max value. +template <class T> +struct NormalizedDefaultValues +{ + static T zero() { return static_cast<T>(0); } + static T one() { return std::numeric_limits<T>::max(); } +}; + +// Converter: +// static const bool identity: true if this is an identity transform (with no widening) +// static const std::size_t finalSize: number of bytes per output vertex +// static void convertArray(const void *in, std::size_t stride, std::size_t n, void *out): convert +// an array of vertices. Input may be strided, but output will be unstrided. + +template <class InT, + class WidenRule, + class Converter, + class DefaultValueRule = SimpleDefaultValues<InT>> +struct VertexDataConverter +{ + typedef typename Converter::OutputType OutputType; + typedef InT InputType; + + static const bool identity = + (WidenRule::initialWidth == WidenRule::finalWidth) && Converter::identity; + static const std::size_t finalSize = WidenRule::finalWidth * sizeof(OutputType); + + static void convertArray(const uint8_t *input, size_t stride, size_t n, uint8_t *output) + { + OutputType *out = reinterpret_cast<OutputType *>(output); + + for (std::size_t i = 0; i < n; i++) + { + const InputType *ein = reinterpret_cast<const InputType *>(input + i * stride); + + copyComponent(out, ein, 0, static_cast<OutputType>(DefaultValueRule::zero())); + copyComponent(out, ein, 1, static_cast<OutputType>(DefaultValueRule::zero())); + copyComponent(out, ein, 2, static_cast<OutputType>(DefaultValueRule::zero())); + copyComponent(out, ein, 3, static_cast<OutputType>(DefaultValueRule::one())); + + out += WidenRule::finalWidth; + } + } + + private: + static void copyComponent(OutputType *out, + const InputType *in, + std::size_t elementindex, + OutputType defaultvalue) + { + if (WidenRule::finalWidth > elementindex) + { + if (WidenRule::initialWidth > elementindex) + { + out[elementindex] = Converter::convert(in[elementindex]); + } + else + { + out[elementindex] = defaultvalue; + } + } + } +}; + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D9_VERTEXCONVERSION_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.cpp b/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.cpp new file mode 100644 index 0000000000..1709f82868 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.cpp @@ -0,0 +1,26 @@ +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// driver_utils_d3d.cpp: Information specific to the D3D driver + +#include "libANGLE/renderer/d3d/driver_utils_d3d.h" + +namespace rx +{ + +std::string GetDriverVersionString(LARGE_INTEGER driverVersion) +{ + std::stringstream versionString; + uint64_t intVersion = driverVersion.QuadPart; + constexpr uint64_t kMask16 = std::numeric_limits<uint16_t>::max(); + versionString << ((intVersion >> 48) & kMask16) << "."; + versionString << ((intVersion >> 32) & kMask16) << "."; + versionString << ((intVersion >> 16) & kMask16) << "."; + versionString << (intVersion & kMask16); + return versionString.str(); +} + +} // namespace rx diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.h new file mode 100644 index 0000000000..3b217838f9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/driver_utils_d3d.h @@ -0,0 +1,21 @@ +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// driver_utils_d3d.h: Information specific to the D3D driver + +#ifndef LIBANGLE_RENDERER_D3D_DRIVER_UTILS_D3D_H_ +#define LIBANGLE_RENDERER_D3D_DRIVER_UTILS_D3D_H_ + +#include "libANGLE/angletypes.h" + +namespace rx +{ + +std::string GetDriverVersionString(LARGE_INTEGER driverVersion); + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_DRIVER_UTILS_D3D_H_ diff --git a/gfx/angle/checkout/src/libANGLE/renderer/d3d/formatutilsD3D.h b/gfx/angle/checkout/src/libANGLE/renderer/d3d/formatutilsD3D.h new file mode 100644 index 0000000000..f0e876d49d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/renderer/d3d/formatutilsD3D.h @@ -0,0 +1,24 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// formatutils9.h: Queries for GL image formats and their translations to D3D +// formats. + +#ifndef LIBANGLE_RENDERER_D3D_FORMATUTILSD3D_H_ +#define LIBANGLE_RENDERER_D3D_FORMATUTILSD3D_H_ + +namespace rx +{ +enum VertexConversionType +{ + VERTEX_CONVERT_NONE = 0, + VERTEX_CONVERT_CPU = 1, + VERTEX_CONVERT_GPU = 2, + VERTEX_CONVERT_BOTH = 3 +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_FORMATUTILSD3D_H_ |