summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp')
-rw-r--r--src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp2164
1 files changed, 1329 insertions, 835 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
index 6bb975b0e4..75c6298868 100644
--- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
+++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
@@ -8,51 +8,51 @@
#include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
-#include <sstream>
#include <EGL/eglext.h>
+#include <sstream>
#include "common/utilities.h"
-#include "libANGLE/angletypes.h"
#include "libANGLE/Buffer.h"
+#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
-#include "libANGLE/features.h"
-#include "libANGLE/formatutils.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/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/formatutils9.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/renderer9_utils.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/CompilerD3D.h"
-#include "libANGLE/renderer/d3d/DeviceD3D.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/TransformFeedbackD3D.h"
-#include "libANGLE/State.h"
-#include "libANGLE/Surface.h"
-#include "libANGLE/Texture.h"
+#include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
+#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
#include "third_party/trace_event/trace_event.h"
-
-
#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL)
#define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3
#endif
@@ -69,69 +69,69 @@ namespace rx
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_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
};
Renderer9::Renderer9(egl::Display *display) : RendererD3D(display), mStateManager(this)
{
- mD3d9Module = NULL;
+ mD3d9Module = nullptr;
- mD3d9 = NULL;
- mD3d9Ex = NULL;
- mDevice = NULL;
- mDeviceEx = NULL;
- mDeviceWindow = NULL;
- mBlit = NULL;
+ mD3d9 = nullptr;
+ mD3d9Ex = nullptr;
+ mDevice = nullptr;
+ mDeviceEx = nullptr;
+ mDeviceWindow = nullptr;
+ mBlit = nullptr;
mAdapter = D3DADAPTER_DEFAULT;
const egl::AttributeMap &attributes = display->getAttributeMap();
- EGLint requestedDeviceType = attributes.get(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE,
- EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE);
+ 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_HARDWARE_ANGLE:
+ mDeviceType = D3DDEVTYPE_HAL;
+ break;
- case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE:
- mDeviceType = D3DDEVTYPE_REF;
- break;
+ case EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE:
+ mDeviceType = D3DDEVTYPE_REF;
+ break;
- case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE:
- mDeviceType = D3DDEVTYPE_NULLREF;
- break;
+ case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE:
+ mDeviceType = D3DDEVTYPE_NULLREF;
+ break;
- default:
- UNREACHABLE();
+ default:
+ UNREACHABLE();
}
- mMaskedClearSavedState = NULL;
+ mMaskedClearSavedState = nullptr;
- mVertexDataManager = NULL;
- mIndexDataManager = NULL;
- mLineLoopIB = NULL;
- mCountingIB = NULL;
+ mVertexDataManager = nullptr;
+ mIndexDataManager = nullptr;
+ mLineLoopIB = nullptr;
+ mCountingIB = nullptr;
mMaxNullColorbufferLRU = 0;
for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
{
mNullColorbufferCache[i].lruCount = 0;
- mNullColorbufferCache[i].width = 0;
- mNullColorbufferCache[i].height = 0;
- mNullColorbufferCache[i].buffer = NULL;
+ mNullColorbufferCache[i].width = 0;
+ mNullColorbufferCache[i].height = 0;
+ mNullColorbufferCache[i].buffer = nullptr;
}
- mAppliedVertexShader = NULL;
- mAppliedPixelShader = NULL;
+ mAppliedVertexShader = nullptr;
+ mAppliedPixelShader = nullptr;
mAppliedProgramSerial = 0;
- initializeDebugAnnotator();
+ gl::InitializeDebugAnnotations(&mAnnotator);
mEGLDevice = nullptr;
}
@@ -154,6 +154,10 @@ void Renderer9::release()
{
RendererD3D::cleanup();
+ gl::UninitializeDebugAnnotations();
+
+ mTranslatedAttribCache.clear();
+
releaseDeviceResources();
SafeDelete(mEGLDevice);
@@ -167,10 +171,10 @@ void Renderer9::release()
if (mDeviceWindow)
{
DestroyWindow(mDeviceWindow);
- mDeviceWindow = NULL;
+ mDeviceWindow = nullptr;
}
- mD3d9Module = NULL;
+ mD3d9Module = nullptr;
}
egl::Error Renderer9::initialize()
@@ -178,22 +182,25 @@ egl::Error Renderer9::initialize()
TRACE_EVENT0("gpu.angle", "GetModuleHandle_d3d9");
mD3d9Module = GetModuleHandle(TEXT("d3d9.dll"));
- if (mD3d9Module == NULL)
+ if (mD3d9Module == nullptr)
{
- return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_MISSING_DEP, "No D3D9 module found.");
+ 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"));
+ 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)))
+ // 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)))
{
TRACE_EVENT0("gpu.angle", "D3d9Ex_QueryInterface");
ASSERT(mD3d9Ex);
- mD3d9Ex->QueryInterface(IID_IDirect3D9, reinterpret_cast<void**>(&mD3d9));
+ mD3d9Ex->QueryInterface(__uuidof(IDirect3D9), reinterpret_cast<void **>(&mD3d9));
ASSERT(mD3d9);
}
else
@@ -204,12 +211,13 @@ egl::Error Renderer9::initialize()
if (!mD3d9)
{
- return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_MISSING_DEP, "Could not create D3D9 device.");
+ 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
+ // UNIMPLEMENTED(); // FIXME: Determine which adapter index the device context
+ // corresponds to
}
HRESULT result;
@@ -226,13 +234,14 @@ egl::Error Renderer9::initialize()
}
else if (result == D3DERR_NOTAVAILABLE)
{
- Sleep(100); // Give the driver some time to initialize/recover
+ 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
+ else if (FAILED(result)) // D3DERR_OUTOFVIDEOMEMORY, E_OUTOFMEMORY,
+ // D3DERR_INVALIDDEVICE, or another error we can't recover
+ // from
{
- return egl::Error(EGL_NOT_INITIALIZED,
- D3D9_INIT_OTHER_ERROR,
- "Failed to get device caps: Error code 0x%x\n", result);
+ return egl::EglNotInitialized(D3D9_INIT_OTHER_ERROR)
+ << "Failed to get device caps, " << gl::FmtHR(result);
}
}
}
@@ -245,18 +254,17 @@ egl::Error Renderer9::initialize()
if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(minShaderModel, 0))
{
- return egl::Error(EGL_NOT_INITIALIZED,
- D3D9_INIT_UNSUPPORTED_VERSION,
- "Renderer does not support PS %u.%u.aborting!", 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.
+ // 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::Error(EGL_NOT_INITIALIZED,
- D3D9_INIT_UNSUPPORTED_STRETCHRECT,
- "Renderer does not support StretctRect from textures.");
+ return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_STRETCHRECT)
+ << "Renderer does not support StretctRect from textures.";
}
{
@@ -265,43 +273,52 @@ egl::Error Renderer9::initialize()
}
static const TCHAR windowName[] = TEXT("AngleHiddenWindow");
- static const TCHAR className[] = TEXT("STATIC");
+ static const TCHAR className[] = TEXT("STATIC");
{
TRACE_EVENT0("gpu.angle", "CreateWindowEx");
- mDeviceWindow = CreateWindowEx(WS_EX_NOACTIVATE, className, windowName, WS_DISABLED | WS_POPUP, 0, 0, 1, 1, HWND_MESSAGE, NULL, GetModuleHandle(NULL), NULL);
+ 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;
+ DWORD behaviorFlags =
+ D3DCREATE_FPU_PRESERVE | D3DCREATE_NOWINDOWCHANGES | D3DCREATE_MULTITHREADED;
{
TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice");
- result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &presentParameters, &mDevice);
+ result = mD3d9->CreateDevice(
+ mAdapter, mDeviceType, mDeviceWindow,
+ behaviorFlags | D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE,
+ &presentParameters, &mDevice);
}
if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST)
{
- return egl::Error(EGL_BAD_ALLOC, D3D9_INIT_OUT_OF_MEMORY,
- "CreateDevice failed: device lost of out of memory");
+ return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY)
+ << "CreateDevice failed: device lost of out of memory";
}
if (FAILED(result))
{
TRACE_EVENT0("gpu.angle", "D3d9_CreateDevice2");
- result = mD3d9->CreateDevice(mAdapter, mDeviceType, mDeviceWindow, behaviorFlags | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParameters, &mDevice);
+ 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::Error(EGL_BAD_ALLOC, D3D9_INIT_OUT_OF_MEMORY,
- "CreateDevice2 failed: device lost, not available, or of out of memory");
+ 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";
}
}
if (mD3d9Ex)
{
TRACE_EVENT0("gpu.angle", "mDevice_QueryInterface");
- result = mDevice->QueryInterface(IID_IDirect3DDevice9Ex, (void**)&mDeviceEx);
+ result = mDevice->QueryInterface(__uuidof(IDirect3DDevice9Ex), (void **)&mDeviceEx);
ASSERT(SUCCEEDED(result));
}
@@ -318,18 +335,19 @@ egl::Error Renderer9::initialize()
// 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));
+ SUCCEEDED(mD3d9->CheckDeviceFormat(
+ mAdapter, mDeviceType, currentDisplayMode.Format,
+ D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F));
- initializeDevice();
+ ANGLE_TRY(initializeDevice());
- return egl::Error(EGL_SUCCESS);
+ 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.
-void Renderer9::initializeDevice()
+egl::Error Renderer9::initializeDevice()
{
// Permanent non-default states
mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
@@ -337,14 +355,14 @@ void Renderer9::initializeDevice()
if (mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
{
- mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD&)mDeviceCaps.MaxPointSize);
+ mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD &)mDeviceCaps.MaxPointSize);
}
else
{
- mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000); // 1.0f
+ mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000); // 1.0f
}
- const gl::Caps &rendererCaps = getRendererCaps();
+ const gl::Caps &rendererCaps = getNativeCaps();
mCurVertexSamplerStates.resize(rendererCaps.maxVertexTextureImageUnits);
mCurPixelSamplerStates.resize(rendererCaps.maxTextureImageUnits);
@@ -358,50 +376,55 @@ void Renderer9::initializeDevice()
ASSERT(!mBlit);
mBlit = new Blit9(this);
- mBlit->initialize();
+ ANGLE_TRY(mBlit->initialize());
ASSERT(!mVertexDataManager && !mIndexDataManager);
mVertexDataManager = new VertexDataManager(this);
- mIndexDataManager = new IndexDataManager(this, getRendererClass());
+ mIndexDataManager = new IndexDataManager(this);
+
+ if (mVertexDataManager->initialize().isError())
+ {
+ return egl::EglBadAlloc() << "Error initializing VertexDataManager";
+ }
+
+ mTranslatedAttribCache.resize(getNativeCaps().maxVertexAttributes);
+
+ mStateManager.initialize();
- // TODO(jmadill): use context caps, and place in common D3D location
- mTranslatedAttribCache.resize(getRendererCaps().maxVertexAttributes);
+ return egl::NoError();
}
D3DPRESENT_PARAMETERS Renderer9::getDefaultPresentParameters()
{
D3DPRESENT_PARAMETERS presentParameters = {0};
- // The default swap chain is never actually used. Surface will create a new swap chain with the proper parameters.
+ // 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.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;
+ 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() const
+egl::ConfigSet Renderer9::generateConfigs()
{
- static const GLenum colorBufferFormats[] =
- {
- GL_BGR5_A1_ANGLEX,
- GL_BGRA8_EXT,
- GL_RGB565,
+ static const GLenum colorBufferFormats[] = {
+ GL_BGR5_A1_ANGLEX, GL_BGRA8_EXT, GL_RGB565,
};
- static const GLenum depthStencilBufferFormats[] =
- {
+ static const GLenum depthStencilBufferFormats[] = {
GL_NONE,
GL_DEPTH_COMPONENT32_OES,
GL_DEPTH24_STENCIL8_OES,
@@ -409,8 +432,8 @@ egl::ConfigSet Renderer9::generateConfigs() const
GL_DEPTH_COMPONENT16,
};
- const gl::Caps &rendererCaps = getRendererCaps();
- const gl::TextureCapsMap &rendererTextureCaps = getRendererTextureCaps();
+ const gl::Caps &rendererCaps = getNativeCaps();
+ const gl::TextureCapsMap &rendererTextureCaps = getNativeTextureCaps();
D3DDISPLAYMODE currentDisplayMode;
mD3d9->GetAdapterDisplayMode(mAdapter, &currentDisplayMode);
@@ -449,56 +472,72 @@ egl::ConfigSet Renderer9::generateConfigs() const
for (size_t formatIndex = 0; formatIndex < ArraySize(colorBufferFormats); formatIndex++)
{
GLenum colorBufferInternalFormat = colorBufferFormats[formatIndex];
- const gl::TextureCaps &colorBufferFormatCaps = rendererTextureCaps.get(colorBufferInternalFormat);
+ const gl::TextureCaps &colorBufferFormatCaps =
+ rendererTextureCaps.get(colorBufferInternalFormat);
if (colorBufferFormatCaps.renderable)
{
- for (size_t depthStencilIndex = 0; depthStencilIndex < ArraySize(depthStencilBufferFormats); depthStencilIndex++)
+ for (size_t depthStencilIndex = 0;
+ depthStencilIndex < ArraySize(depthStencilBufferFormats); depthStencilIndex++)
{
- GLenum depthStencilBufferInternalFormat = depthStencilBufferFormats[depthStencilIndex];
- const gl::TextureCaps &depthStencilBufferFormatCaps = rendererTextureCaps.get(depthStencilBufferInternalFormat);
- if (depthStencilBufferFormatCaps.renderable || depthStencilBufferInternalFormat == GL_NONE)
+ GLenum depthStencilBufferInternalFormat =
+ depthStencilBufferFormats[depthStencilIndex];
+ const gl::TextureCaps &depthStencilBufferFormatCaps =
+ rendererTextureCaps.get(depthStencilBufferInternalFormat);
+ if (depthStencilBufferFormatCaps.renderable ||
+ depthStencilBufferInternalFormat == GL_NONE)
{
- const gl::InternalFormat &colorBufferFormatInfo = gl::GetInternalFormatInfo(colorBufferInternalFormat);
- const gl::InternalFormat &depthStencilBufferFormatInfo = gl::GetInternalFormatInfo(depthStencilBufferInternalFormat);
- const d3d9::TextureFormat &d3d9ColorBufferFormatInfo = d3d9::GetTextureFormatInfo(colorBufferInternalFormat);
+ 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.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.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.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.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.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.transparentBlueValue = 0;
+ config.colorComponentType = gl_egl::GLComponentTypeToEGLColorComponentType(
+ colorBufferFormatInfo.componentType);
configs.add(config);
}
@@ -519,13 +558,12 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions)
outExtensions->d3dShareHandleClientBuffer = true;
outExtensions->surfaceD3DTexture2DShareHandle = true;
}
+ outExtensions->d3dTextureClientBuffer = true;
outExtensions->querySurfacePointer = true;
outExtensions->windowFixedSize = true;
outExtensions->postSubBuffer = true;
- outExtensions->createContext = true;
outExtensions->deviceQuery = true;
- outExtensions->createContextNoError = true;
outExtensions->image = true;
outExtensions->imageBase = true;
@@ -533,6 +571,14 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions)
outExtensions->glRenderbufferImage = true;
outExtensions->flexibleSurfaceCompatibility = true;
+
+ // Contexts are virtualized so textures can be shared globally
+ outExtensions->displayTextureShareGroup = true;
+
+ // D3D9 can be used without an output surface
+ outExtensions->surfacelessContext = true;
+
+ outExtensions->robustResourceInitialization = true;
}
void Renderer9::startScene()
@@ -540,7 +586,8 @@ void Renderer9::startScene()
if (!mSceneStarted)
{
long result = mDevice->BeginScene();
- if (SUCCEEDED(result)) {
+ if (SUCCEEDED(result))
+ {
// This is defensive checking against the device being
// lost at unexpected times.
mSceneStarted = true;
@@ -561,8 +608,8 @@ void Renderer9::endScene()
gl::Error Renderer9::flush()
{
- IDirect3DQuery9* query = NULL;
- gl::Error error = allocateEventQuery(&query);
+ IDirect3DQuery9 *query = nullptr;
+ gl::Error error = allocateEventQuery(&query);
if (error.isError())
{
return error;
@@ -572,11 +619,11 @@ gl::Error Renderer9::flush()
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to issue event query, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
}
// Grab the query data once
- result = query->GetData(NULL, 0, D3DGETDATA_FLUSH);
+ result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
freeEventQuery(query);
if (FAILED(result))
{
@@ -585,16 +632,16 @@ gl::Error Renderer9::flush()
notifyDeviceLost();
}
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
gl::Error Renderer9::finish()
{
- IDirect3DQuery9* query = NULL;
- gl::Error error = allocateEventQuery(&query);
+ IDirect3DQuery9 *query = nullptr;
+ gl::Error error = allocateEventQuery(&query);
if (error.isError())
{
return error;
@@ -604,11 +651,11 @@ gl::Error Renderer9::finish()
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to issue event query, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
}
// Grab the query data once
- result = query->GetData(NULL, 0, D3DGETDATA_FLUSH);
+ result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
if (FAILED(result))
{
if (d3d9::isDeviceLostError(result))
@@ -617,7 +664,7 @@ gl::Error Renderer9::finish()
}
freeEventQuery(query);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
}
// Loop until the query completes
@@ -626,7 +673,7 @@ gl::Error Renderer9::finish()
// Keep polling, but allow other threads to do something useful first
ScheduleYield();
- result = query->GetData(NULL, 0, D3DGETDATA_FLUSH);
+ result = query->GetData(nullptr, 0, D3DGETDATA_FLUSH);
// explicitly check for device loss
// some drivers seem to return S_FALSE even if the device is lost
@@ -644,34 +691,146 @@ gl::Error Renderer9::finish()
}
freeEventQuery(query);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
}
-
}
freeEventQuery(query);
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
+}
+
+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(NativeWindow nativeWindow,
+SwapChainD3D *Renderer9::createSwapChain(NativeWindowD3D *nativeWindow,
HANDLE shareHandle,
+ IUnknown *d3dTexture,
GLenum backBufferFormat,
GLenum depthBufferFormat,
- EGLint orientation)
+ EGLint orientation,
+ EGLint samples)
{
- return new SwapChain9(this, nativeWindow, shareHandle, backBufferFormat, depthBufferFormat,
- orientation);
+ return new SwapChain9(this, GetAs<NativeWindow9>(nativeWindow), shareHandle, d3dTexture,
+ backBufferFormat, depthBufferFormat, orientation);
}
-CompilerImpl *Renderer9::createCompiler()
+egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
+ IUnknown *d3dTexture,
+ EGLint *width,
+ EGLint *height,
+ GLenum *fboFormat) const
{
- return new CompilerD3D(SH_HLSL_3_0_OUTPUT);
+ 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);
+ }
+
+ // 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;
+ }
+
+ if (fboFormat)
+ {
+ const auto &d3dFormatInfo = d3d9::GetD3DFormatInfo(desc.Format);
+ ASSERT(d3dFormatInfo.info().id != angle::Format::ID::NONE);
+ *fboFormat = d3dFormatInfo.info().fboImplementationInternalFormat;
+ }
+
+ 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::ContextState &state)
+{
+ return new Context9(state, this);
}
void *Renderer9::getD3DDevice()
{
- return reinterpret_cast<void*>(mDevice);
+ return reinterpret_cast<void *>(mDevice);
}
gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
@@ -682,7 +841,7 @@ gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate event query, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to allocate event query, " << gl::FmtHR(result);
}
}
else
@@ -691,10 +850,10 @@ gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
mEventQueryPool.pop_back();
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-void Renderer9::freeEventQuery(IDirect3DQuery9* query)
+void Renderer9::freeEventQuery(IDirect3DQuery9 *query)
{
if (mEventQueryPool.size() > 1000)
{
@@ -706,20 +865,26 @@ void Renderer9::freeEventQuery(IDirect3DQuery9* query)
}
}
-gl::Error Renderer9::createVertexShader(const DWORD *function, size_t length, IDirect3DVertexShader9 **outShader)
+gl::Error Renderer9::createVertexShader(const DWORD *function,
+ size_t length,
+ IDirect3DVertexShader9 **outShader)
{
return mVertexShaderCache.create(function, length, outShader);
}
-gl::Error Renderer9::createPixelShader(const DWORD *function, size_t length, IDirect3DPixelShader9 **outShader)
+gl::Error Renderer9::createPixelShader(const DWORD *function,
+ size_t length,
+ IDirect3DPixelShader9 **outShader)
{
return mPixelShaderCache.create(function, length, outShader);
}
-HRESULT Renderer9::createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer)
+HRESULT Renderer9::createVertexBuffer(UINT Length,
+ DWORD Usage,
+ IDirect3DVertexBuffer9 **ppVertexBuffer)
{
D3DPOOL Pool = getBufferPool(Usage);
- return mDevice->CreateVertexBuffer(Length, Usage, 0, Pool, ppVertexBuffer, NULL);
+ return mDevice->CreateVertexBuffer(Length, Usage, 0, Pool, ppVertexBuffer, nullptr);
}
VertexBuffer *Renderer9::createVertexBuffer()
@@ -727,10 +892,13 @@ VertexBuffer *Renderer9::createVertexBuffer()
return new VertexBuffer9(this);
}
-HRESULT Renderer9::createIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, IDirect3DIndexBuffer9 **ppIndexBuffer)
+HRESULT Renderer9::createIndexBuffer(UINT Length,
+ DWORD Usage,
+ D3DFORMAT Format,
+ IDirect3DIndexBuffer9 **ppIndexBuffer)
{
D3DPOOL Pool = getBufferPool(Usage);
- return mDevice->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, NULL);
+ return mDevice->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, nullptr);
}
IndexBuffer *Renderer9::createIndexBuffer()
@@ -738,36 +906,13 @@ IndexBuffer *Renderer9::createIndexBuffer()
return new IndexBuffer9(this);
}
-BufferImpl *Renderer9::createBuffer()
-{
- return new Buffer9(this);
-}
-
-VertexArrayImpl *Renderer9::createVertexArray(const gl::VertexArray::Data &data)
-{
- return new VertexArray9(data);
-}
-
-QueryImpl *Renderer9::createQuery(GLenum type)
-{
- return new Query9(this, type);
-}
-
-FenceNVImpl *Renderer9::createFenceNV()
-{
- return new FenceNV9(this);
-}
-
-FenceSyncImpl *Renderer9::createFenceSync()
+StreamProducerImpl *Renderer9::createStreamProducerD3DTextureNV12(
+ egl::Stream::ConsumerType consumerType,
+ const egl::AttributeMap &attribs)
{
- // Renderer9 doesn't support ES 3.0 and its sync objects.
+ // Streams are not supported under D3D9
UNREACHABLE();
- return NULL;
-}
-
-TransformFeedbackImpl* Renderer9::createTransformFeedback()
-{
- return new TransformFeedbackD3D();
+ return nullptr;
}
bool Renderer9::supportsFastCopyBufferToTexture(GLenum internalFormat) const
@@ -776,22 +921,24 @@ bool Renderer9::supportsFastCopyBufferToTexture(GLenum internalFormat) const
return false;
}
-gl::Error Renderer9::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
- GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea)
+gl::Error Renderer9::fastCopyBufferToTexture(const gl::Context *context,
+ const gl::PixelUnpackState &unpack,
+ 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.
UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
-}
-
-gl::Error Renderer9::generateSwizzle(gl::Texture *texture)
-{
- // Swizzled textures are not available in ES2 or D3D9
- UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ return gl::InternalError();
}
-gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &samplerState)
+gl::Error Renderer9::setSamplerState(const gl::Context *context,
+ gl::SamplerType type,
+ int index,
+ gl::Texture *texture,
+ const gl::SamplerState &samplerState)
{
CurSamplerState &appliedSampler = (type == gl::SAMPLER_PIXEL) ? mCurPixelSamplerStates[index]
: mCurVertexSamplerStates[index];
@@ -800,11 +947,7 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Textur
TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
TextureStorage *storage = nullptr;
- gl::Error error = textureD3D->getNativeTexture(&storage);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(textureD3D->getNativeTexture(context, &storage));
// Storage should exist, texture should be complete
ASSERT(storage);
@@ -815,12 +958,16 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Textur
memcmp(&samplerState, &appliedSampler, sizeof(gl::SamplerState)) != 0)
{
int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
- int d3dSampler = index + d3dSamplerOffset;
+ int d3dSampler = index + d3dSamplerOffset;
- mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU, gl_d3d9::ConvertTextureWrap(samplerState.wrapS));
- mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV, gl_d3d9::ConvertTextureWrap(samplerState.wrapT));
+ mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU,
+ gl_d3d9::ConvertTextureWrap(samplerState.wrapS));
+ mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV,
+ gl_d3d9::ConvertTextureWrap(samplerState.wrapT));
- mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAGFILTER, gl_d3d9::ConvertMagFilter(samplerState.magFilter, samplerState.maxAnisotropy));
+ mDevice->SetSamplerState(
+ d3dSampler, D3DSAMP_MAGFILTER,
+ gl_d3d9::ConvertMagFilter(samplerState.magFilter, samplerState.maxAnisotropy));
D3DTEXTUREFILTERTYPE d3dMinFilter, d3dMipFilter;
float lodBias;
@@ -830,52 +977,50 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Textur
mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPFILTER, d3dMipFilter);
mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXMIPLEVEL, baseLevel);
mDevice->SetSamplerState(d3dSampler, D3DSAMP_MIPMAPLODBIAS, static_cast<DWORD>(lodBias));
- if (getRendererExtensions().textureFilterAnisotropic)
+ if (getNativeExtensions().textureFilterAnisotropic)
{
- mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXANISOTROPY, (DWORD)samplerState.maxAnisotropy);
+ DWORD maxAnisotropy =
+ std::min(mDeviceCaps.MaxAnisotropy, static_cast<DWORD>(samplerState.maxAnisotropy));
+ mDevice->SetSamplerState(d3dSampler, D3DSAMP_MAXANISOTROPY, maxAnisotropy);
}
}
- appliedSampler.forceSet = false;
+ appliedSampler.forceSet = false;
appliedSampler.samplerState = samplerState;
- appliedSampler.baseLevel = baseLevel;
+ appliedSampler.baseLevel = baseLevel;
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
+gl::Error Renderer9::setTexture(const gl::Context *context,
+ gl::SamplerType type,
+ int index,
+ gl::Texture *texture)
{
- int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
- int d3dSampler = index + d3dSamplerOffset;
- IDirect3DBaseTexture9 *d3dTexture = NULL;
- bool forceSetTexture = false;
+ int d3dSamplerOffset = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
+ int d3dSampler = index + d3dSamplerOffset;
+ IDirect3DBaseTexture9 *d3dTexture = nullptr;
+ bool forceSetTexture = false;
- std::vector<uintptr_t> &appliedTextures = (type == gl::SAMPLER_PIXEL) ? mCurPixelTextures : mCurVertexTextures;
+ std::vector<uintptr_t> &appliedTextures =
+ (type == gl::SAMPLER_PIXEL) ? mCurPixelTextures : mCurVertexTextures;
if (texture)
{
TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
TextureStorage *texStorage = nullptr;
- gl::Error error = textureImpl->getNativeTexture(&texStorage);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage));
// Texture should be complete and have a storage
ASSERT(texStorage);
TextureStorage9 *storage9 = GetAs<TextureStorage9>(texStorage);
- error = storage9->getBaseTexture(&d3dTexture);
- if (error.isError())
- {
- return error;
- }
+ 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 != NULL);
+ ASSERT(d3dTexture != nullptr);
forceSetTexture = textureImpl->hasDirtyImages();
textureImpl->resetDirty();
@@ -888,60 +1033,50 @@ gl::Error Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *te
appliedTextures[index] = reinterpret_cast<uintptr_t>(d3dTexture);
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::setUniformBuffers(const gl::Data &/*data*/,
- const std::vector<GLint> &/*vertexUniformBuffers*/,
- const std::vector<GLint> &/*fragmentUniformBuffers*/)
+gl::Error Renderer9::updateState(const gl::Context *context, GLenum drawMode)
{
- // No effect in ES2/D3D9
- return gl::Error(GL_NO_ERROR);
-}
+ const auto &glState = context->getGLState();
-void Renderer9::syncState(const gl::State &state, const gl::State::DirtyBits &bitmask)
-{
- mStateManager.syncState(state, bitmask);
-}
-
-gl::Error Renderer9::updateState(const gl::Data &data, GLenum drawMode)
-{
// Applies the render target surface, depth stencil surface, viewport rectangle and
// scissor rectangle to the renderer
- const gl::Framebuffer *framebufferObject = data.state->getDrawFramebuffer();
- ASSERT(framebufferObject && framebufferObject->checkStatus(data) == GL_FRAMEBUFFER_COMPLETE);
+ gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
+ ASSERT(framebuffer && !framebuffer->hasAnyDirtyBit() && framebuffer->cachedComplete());
- gl::Error error = applyRenderTarget(framebufferObject);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(applyRenderTarget(context, framebuffer));
// Setting viewport state
- setViewport(data.caps, data.state->getViewport(), data.state->getNearPlane(),
- data.state->getFarPlane(), drawMode, data.state->getRasterizerState().frontFace,
- false);
+ setViewport(glState.getViewport(), glState.getNearPlane(), glState.getFarPlane(), drawMode,
+ glState.getRasterizerState().frontFace, false);
// Setting scissors state
- setScissorRectangle(data.state->getScissor(), data.state->isScissorTestEnabled());
+ setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
// Setting blend, depth stencil, and rasterizer states
- int samples = framebufferObject->getSamples(data);
- gl::RasterizerState rasterizer = data.state->getRasterizerState();
+ // 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->getFirstColorbuffer();
+ if (firstColorAttachment)
+ {
+ ASSERT(firstColorAttachment->isAttached());
+ RenderTarget9 *renderTarget = nullptr;
+ ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
+ samples = renderTarget->getSamples();
+ }
+ gl::RasterizerState rasterizer = glState.getRasterizerState();
rasterizer.pointDrawMode = (drawMode == GL_POINTS);
rasterizer.multiSample = (samples != 0);
- unsigned int mask = GetBlendSampleMask(data, samples);
- error = setBlendDepthRasterStates(data, mask);
-
- if (error.isError())
- {
- return error;
- }
+ unsigned int mask = GetBlendSampleMask(glState, samples);
+ ANGLE_TRY(setBlendDepthRasterStates(context, mask));
mStateManager.resetDirtyBits();
- return error;
+ return gl::NoError();
}
void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
@@ -949,71 +1084,85 @@ void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
mStateManager.setScissorState(scissor, enabled);
}
-gl::Error Renderer9::setBlendDepthRasterStates(const gl::Data &glData, GLenum drawMode)
+gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context, GLenum drawMode)
{
- int samples = glData.state->getDrawFramebuffer()->getSamples(glData);
- gl::RasterizerState rasterizer = glData.state->getRasterizerState();
+ const auto &glState = context->getGLState();
+ 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->getFirstColorbuffer();
+ if (firstColorAttachment)
+ {
+ ASSERT(firstColorAttachment->isAttached());
+ RenderTarget9 *renderTarget = nullptr;
+ ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
+ samples = renderTarget->getSamples();
+ }
+ gl::RasterizerState rasterizer = glState.getRasterizerState();
rasterizer.pointDrawMode = (drawMode == GL_POINTS);
rasterizer.multiSample = (samples != 0);
- unsigned int mask = GetBlendSampleMask(glData, samples);
- return mStateManager.setBlendDepthRasterStates(*glData.state, mask);
+ unsigned int mask = GetBlendSampleMask(glState, samples);
+ return mStateManager.setBlendDepthRasterStates(glState, mask);
}
-void Renderer9::setViewport(const gl::Caps *caps,
- const gl::Rectangle &viewport,
+void Renderer9::setViewport(const gl::Rectangle &viewport,
float zNear,
float zFar,
GLenum drawMode,
GLenum frontFace,
bool ignoreViewport)
{
- mStateManager.setViewportState(caps, viewport, zNear, zFar, drawMode, frontFace,
- ignoreViewport);
+ mStateManager.setViewportState(viewport, zNear, zFar, drawMode, frontFace, ignoreViewport);
}
bool Renderer9::applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSize)
{
switch (mode)
{
- case GL_POINTS:
- mPrimitiveType = D3DPT_POINTLIST;
- mPrimitiveCount = count;
- break;
- case GL_LINES:
- mPrimitiveType = D3DPT_LINELIST;
- mPrimitiveCount = count / 2;
- break;
- case GL_LINE_LOOP:
- mPrimitiveType = D3DPT_LINESTRIP;
- mPrimitiveCount = count - 1; // D3D doesn't support line loops, so we draw the last line separately
- break;
- case GL_LINE_STRIP:
- mPrimitiveType = D3DPT_LINESTRIP;
- mPrimitiveCount = count - 1;
- break;
- case GL_TRIANGLES:
- mPrimitiveType = D3DPT_TRIANGLELIST;
- mPrimitiveCount = count / 3;
- break;
- case GL_TRIANGLE_STRIP:
- mPrimitiveType = D3DPT_TRIANGLESTRIP;
- mPrimitiveCount = count - 2;
- break;
- case GL_TRIANGLE_FAN:
- mPrimitiveType = D3DPT_TRIANGLEFAN;
- mPrimitiveCount = count - 2;
- break;
- default:
- UNREACHABLE();
- return false;
+ case GL_POINTS:
+ mPrimitiveType = D3DPT_POINTLIST;
+ mPrimitiveCount = count;
+ break;
+ case GL_LINES:
+ mPrimitiveType = D3DPT_LINELIST;
+ mPrimitiveCount = count / 2;
+ break;
+ case GL_LINE_LOOP:
+ mPrimitiveType = D3DPT_LINESTRIP;
+ mPrimitiveCount =
+ count - 1; // D3D doesn't support line loops, so we draw the last line separately
+ break;
+ case GL_LINE_STRIP:
+ mPrimitiveType = D3DPT_LINESTRIP;
+ mPrimitiveCount = count - 1;
+ break;
+ case GL_TRIANGLES:
+ mPrimitiveType = D3DPT_TRIANGLELIST;
+ mPrimitiveCount = count / 3;
+ break;
+ case GL_TRIANGLE_STRIP:
+ mPrimitiveType = D3DPT_TRIANGLESTRIP;
+ mPrimitiveCount = count - 2;
+ break;
+ case GL_TRIANGLE_FAN:
+ mPrimitiveType = D3DPT_TRIANGLEFAN;
+ mPrimitiveCount = count - 2;
+ break;
+ default:
+ UNREACHABLE();
+ return false;
}
return mPrimitiveCount > 0;
}
-
-gl::Error Renderer9::getNullColorbuffer(const gl::FramebufferAttachment *depthbuffer, const gl::FramebufferAttachment **outColorBuffer)
+gl::Error Renderer9::getNullColorbuffer(const gl::Context *context,
+ const gl::FramebufferAttachment *depthbuffer,
+ const gl::FramebufferAttachment **outColorBuffer)
{
ASSERT(depthbuffer);
@@ -1022,25 +1171,28 @@ gl::Error Renderer9::getNullColorbuffer(const gl::FramebufferAttachment *depthbu
// search cached nullcolorbuffers
for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
{
- if (mNullColorbufferCache[i].buffer != NULL &&
+ if (mNullColorbufferCache[i].buffer != nullptr &&
mNullColorbufferCache[i].width == size.width &&
mNullColorbufferCache[i].height == size.height)
{
mNullColorbufferCache[i].lruCount = ++mMaxNullColorbufferLRU;
- *outColorBuffer = mNullColorbufferCache[i].buffer;
- return gl::Error(GL_NO_ERROR);
+ *outColorBuffer = mNullColorbufferCache[i].buffer;
+ return gl::NoError();
}
}
- gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(createRenderbuffer(), 0);
- gl::Error error = nullRenderbuffer->setStorage(GL_NONE, size.width, size.height);
+ auto *implFactory = context->getImplementation();
+
+ gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(implFactory->createRenderbuffer(), 0);
+ gl::Error error = nullRenderbuffer->setStorage(context, GL_NONE, size.width, size.height);
if (error.isError())
{
SafeDelete(nullRenderbuffer);
return error;
}
- gl::FramebufferAttachment *nullbuffer = new gl::FramebufferAttachment(GL_RENDERBUFFER, GL_NONE, gl::ImageIndex::MakeInvalid(), nullRenderbuffer);
+ gl::FramebufferAttachment *nullbuffer = new gl::FramebufferAttachment(
+ context, GL_RENDERBUFFER, GL_NONE, gl::ImageIndex::MakeInvalid(), nullRenderbuffer);
// add nullbuffer to the cache
NullColorbufferCacheEntry *oldest = &mNullColorbufferCache[0];
@@ -1053,46 +1205,38 @@ gl::Error Renderer9::getNullColorbuffer(const gl::FramebufferAttachment *depthbu
}
delete oldest->buffer;
- oldest->buffer = nullbuffer;
+ oldest->buffer = nullbuffer;
oldest->lruCount = ++mMaxNullColorbufferLRU;
oldest->width = size.width;
oldest->height = size.height;
*outColorBuffer = nullbuffer;
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAttachment,
+gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
+ const gl::FramebufferAttachment *colorAttachment,
const gl::FramebufferAttachment *depthStencilAttachment)
{
const gl::FramebufferAttachment *renderAttachment = colorAttachment;
- gl::Error error(GL_NO_ERROR);
// 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.
if (renderAttachment == nullptr)
{
- error = getNullColorbuffer(depthStencilAttachment, &renderAttachment);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(getNullColorbuffer(context, depthStencilAttachment, &renderAttachment));
}
ASSERT(renderAttachment != nullptr);
- size_t renderTargetWidth = 0;
- size_t renderTargetHeight = 0;
+ size_t renderTargetWidth = 0;
+ size_t renderTargetHeight = 0;
D3DFORMAT renderTargetFormat = D3DFMT_UNKNOWN;
RenderTarget9 *renderTarget = nullptr;
- error = renderAttachment->getRenderTarget(&renderTarget);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(renderAttachment->getRenderTarget(context, &renderTarget));
ASSERT(renderTarget);
- bool renderTargetChanged = false;
+ bool renderTargetChanged = false;
unsigned int renderTargetSerial = renderTarget->getSerial();
if (renderTargetSerial != mAppliedRenderTargetSerial)
{
@@ -1103,24 +1247,20 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAtt
mDevice->SetRenderTarget(0, renderTargetSurface);
SafeRelease(renderTargetSurface);
- renderTargetWidth = renderTarget->getWidth();
+ renderTargetWidth = renderTarget->getWidth();
renderTargetHeight = renderTarget->getHeight();
renderTargetFormat = renderTarget->getD3DFormat();
mAppliedRenderTargetSerial = renderTargetSerial;
- renderTargetChanged = true;
+ renderTargetChanged = true;
}
RenderTarget9 *depthStencilRenderTarget = nullptr;
- unsigned int depthStencilSerial = 0;
+ unsigned int depthStencilSerial = 0;
if (depthStencilAttachment != nullptr)
{
- error = depthStencilAttachment->getRenderTarget(&depthStencilRenderTarget);
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &depthStencilRenderTarget));
ASSERT(depthStencilRenderTarget);
depthStencilSerial = depthStencilRenderTarget->getSerial();
@@ -1128,7 +1268,7 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAtt
if (depthStencilSerial != mAppliedDepthStencilSerial || !mDepthStencilInitialized)
{
- unsigned int depthSize = 0;
+ unsigned int depthSize = 0;
unsigned int stencilSize = 0;
// Apply the depth stencil on the device
@@ -1140,19 +1280,19 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAtt
mDevice->SetDepthStencilSurface(depthStencilSurface);
SafeRelease(depthStencilSurface);
- depthSize = depthStencilAttachment->getDepthSize();
+ depthSize = depthStencilAttachment->getDepthSize();
stencilSize = depthStencilAttachment->getStencilSize();
}
else
{
- mDevice->SetDepthStencilSurface(NULL);
+ mDevice->SetDepthStencilSurface(nullptr);
}
mStateManager.updateDepthSizeIfChanged(mDepthStencilInitialized, depthSize);
mStateManager.updateStencilSizeIfChanged(mDepthStencilInitialized, stencilSize);
mAppliedDepthStencilSerial = depthStencilSerial;
- mDepthStencilInitialized = true;
+ mDepthStencilInitialized = true;
}
if (renderTargetChanged || !mRenderTargetDescInitialized)
@@ -1163,83 +1303,84 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAtt
mRenderTargetDescInitialized = true;
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::applyRenderTarget(const gl::Framebuffer *framebuffer)
+gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
+ const gl::Framebuffer *framebuffer)
{
- return applyRenderTarget(framebuffer->getColorbuffer(0), framebuffer->getDepthOrStencilbuffer());
+ return applyRenderTarget(context, framebuffer->getColorbuffer(0),
+ framebuffer->getDepthOrStencilbuffer());
}
-gl::Error Renderer9::applyVertexBuffer(const gl::State &state,
+gl::Error Renderer9::applyVertexBuffer(const gl::Context *context,
GLenum mode,
GLint first,
GLsizei count,
GLsizei instances,
TranslatedIndexData * /*indexInfo*/)
{
- gl::Error error = mVertexDataManager->prepareVertexData(state, first, count, &mTranslatedAttribCache, instances);
+ const gl::State &state = context->getGLState();
+ gl::Error error = mVertexDataManager->prepareVertexData(context, first, count,
+ &mTranslatedAttribCache, instances);
if (error.isError())
{
return error;
}
- return mVertexDeclarationCache.applyDeclaration(mDevice, mTranslatedAttribCache, state.getProgram(), instances, &mRepeatDraw);
+ return mVertexDeclarationCache.applyDeclaration(
+ mDevice, mTranslatedAttribCache, state.getProgram(), first, instances, &mRepeatDraw);
}
// Applies the indices and element array bindings to the Direct3D 9 device
-gl::Error Renderer9::applyIndexBuffer(const gl::Data &data,
- const GLvoid *indices,
+gl::Error Renderer9::applyIndexBuffer(const gl::Context *context,
+ const void *indices,
GLsizei count,
GLenum mode,
GLenum type,
TranslatedIndexData *indexInfo)
{
- gl::VertexArray *vao = data.state->getVertexArray();
+ gl::VertexArray *vao = context->getGLState().getVertexArray();
gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
- gl::Error error = mIndexDataManager->prepareIndexData(type, count, elementArrayBuffer, indices,
- indexInfo, false);
- if (error.isError())
- {
- return error;
- }
+ const auto &lazyIndexRange = context->getParams<gl::HasIndexRange>();
+
+ GLenum dstType = GetIndexTranslationDestType(type, lazyIndexRange, false);
+
+ ANGLE_TRY(mIndexDataManager->prepareIndexData(context, type, dstType, count, elementArrayBuffer,
+ indices, indexInfo));
// Directly binding the storage buffer is not supported for d3d9
- ASSERT(indexInfo->storage == NULL);
+ ASSERT(indexInfo->storage == nullptr);
if (indexInfo->serial != mAppliedIBSerial)
{
- IndexBuffer9* indexBuffer = GetAs<IndexBuffer9>(indexInfo->indexBuffer);
+ IndexBuffer9 *indexBuffer = GetAs<IndexBuffer9>(indexInfo->indexBuffer);
mDevice->SetIndices(indexBuffer->getBuffer());
mAppliedIBSerial = indexInfo->serial;
}
- return gl::Error(GL_NO_ERROR);
-}
-
-void Renderer9::applyTransformFeedbackBuffers(const gl::State& state)
-{
- ASSERT(!state.isTransformFeedbackActiveUnpaused());
+ return gl::NoError();
}
-gl::Error Renderer9::drawArraysImpl(const gl::Data &data,
+gl::Error Renderer9::drawArraysImpl(const gl::Context *context,
GLenum mode,
+ GLint startVertex,
GLsizei count,
GLsizei instances)
{
- ASSERT(!data.state->isTransformFeedbackActiveUnpaused());
+ ASSERT(!context->getGLState().isTransformFeedbackActiveUnpaused());
startScene();
if (mode == GL_LINE_LOOP)
{
- return drawLineLoop(count, GL_NONE, NULL, 0, NULL);
+ return drawLineLoop(context, count, GL_NONE, nullptr, 0, nullptr);
}
else if (instances > 0)
{
- StaticIndexBufferInterface *countingIB = NULL;
- gl::Error error = getCountingIB(count, &countingIB);
+ StaticIndexBufferInterface *countingIB = nullptr;
+ gl::Error error = getCountingIB(count, &countingIB);
if (error.isError())
{
return error;
@@ -1258,60 +1399,73 @@ gl::Error Renderer9::drawArraysImpl(const gl::Data &data,
mDevice->DrawIndexedPrimitive(mPrimitiveType, 0, 0, count, 0, mPrimitiveCount);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
- else // Regular case
+ else // Regular case
{
mDevice->DrawPrimitive(mPrimitiveType, 0, mPrimitiveCount);
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
}
-gl::Error Renderer9::drawElementsImpl(const gl::Data &data,
- const TranslatedIndexData &indexInfo,
+gl::Error Renderer9::drawElementsImpl(const gl::Context *context,
GLenum mode,
GLsizei count,
GLenum type,
- const GLvoid *indices,
- GLsizei /*instances*/)
+ const void *indices,
+ GLsizei instances)
{
+ TranslatedIndexData indexInfo;
+
+ ANGLE_TRY(applyIndexBuffer(context, indices, count, mode, type, &indexInfo));
+
+ const auto &lazyIndexRange = context->getParams<gl::HasIndexRange>();
+ const gl::IndexRange &indexRange = lazyIndexRange.getIndexRange().value();
+ 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>(indexInfo.indexRange.start);
+ int minIndex = static_cast<int>(indexRange.start);
- gl::VertexArray *vao = data.state->getVertexArray();
+ gl::VertexArray *vao = context->getGLState().getVertexArray();
gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
if (mode == GL_POINTS)
{
- return drawIndexedPoints(count, type, indices, minIndex, elementArrayBuffer);
+ return drawIndexedPoints(context, count, type, indices, minIndex, elementArrayBuffer);
}
else if (mode == GL_LINE_LOOP)
{
- return drawLineLoop(count, type, indices, minIndex, elementArrayBuffer);
+ return drawLineLoop(context, count, type, indices, minIndex, elementArrayBuffer);
}
else
{
- size_t vertexCount = indexInfo.indexRange.vertexCount();
for (int i = 0; i < mRepeatDraw; i++)
{
mDevice->DrawIndexedPrimitive(mPrimitiveType, -minIndex, minIndex,
static_cast<UINT>(vertexCount), indexInfo.startIndex,
mPrimitiveCount);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
}
-gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
+gl::Error Renderer9::drawLineLoop(const gl::Context *context,
+ GLsizei count,
+ GLenum type,
+ const void *indices,
+ int minIndex,
+ gl::Buffer *elementArrayBuffer)
{
// Get the raw indices for an indexed draw
if (type != GL_NONE && elementArrayBuffer)
{
- BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer);
- intptr_t offset = reinterpret_cast<intptr_t>(indices);
- const uint8_t *bufferData = NULL;
- gl::Error error = storage->getData(&bufferData);
+ BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer);
+ intptr_t offset = reinterpret_cast<intptr_t>(indices);
+ const uint8_t *bufferData = nullptr;
+ gl::Error error = storage->getData(context, &bufferData);
if (error.isError())
{
return error;
@@ -1321,12 +1475,13 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
unsigned int startIndex = 0;
- if (getRendererExtensions().elementIndexUint)
+ if (getNativeExtensions().elementIndexUint)
{
if (!mLineLoopIB)
{
mLineLoopIB = new StreamingIndexBufferInterface(this);
- gl::Error error = mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
+ gl::Error error =
+ mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
if (error.isError())
{
SafeDelete(mLineLoopIB);
@@ -1337,60 +1492,64 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
// Checked by Renderer9::applyPrimitiveType
ASSERT(count >= 0);
- if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
+ if (static_cast<unsigned int>(count) + 1 >
+ (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
{
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to create a 32-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
+ return gl::OutOfMemory() << "Failed to create a 32-bit looping index buffer for "
+ "GL_LINE_LOOP, too many indices required.";
}
- const unsigned int spaceNeeded = (static_cast<unsigned int>(count)+1) * sizeof(unsigned int);
+ const unsigned int spaceNeeded =
+ (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
gl::Error error = mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
if (error.isError())
{
return error;
}
- void* mappedMemory = NULL;
+ void *mappedMemory = nullptr;
unsigned int offset = 0;
- error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
+ error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
if (error.isError())
{
return error;
}
- startIndex = static_cast<unsigned int>(offset) / 4;
- unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
+ startIndex = static_cast<unsigned int>(offset) / 4;
+ unsigned int *data = reinterpret_cast<unsigned int *>(mappedMemory);
switch (type)
{
- case GL_NONE: // Non-indexed draw
- for (int i = 0; i < count; i++)
- {
- data[i] = i;
- }
- data[count] = 0;
- break;
- case GL_UNSIGNED_BYTE:
- 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_UNSIGNED_SHORT:
- 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_UNSIGNED_INT:
- 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();
+ case GL_NONE: // Non-indexed draw
+ for (int i = 0; i < count; i++)
+ {
+ data[i] = i;
+ }
+ data[count] = 0;
+ break;
+ case GL_UNSIGNED_BYTE:
+ 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_UNSIGNED_SHORT:
+ 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_UNSIGNED_INT:
+ 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();
}
error = mLineLoopIB->unmapBuffer();
@@ -1404,7 +1563,8 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
if (!mLineLoopIB)
{
mLineLoopIB = new StreamingIndexBufferInterface(this);
- gl::Error error = mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT);
+ gl::Error error =
+ mLineLoopIB->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT);
if (error.isError())
{
SafeDelete(mLineLoopIB);
@@ -1415,19 +1575,22 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
// Checked by Renderer9::applyPrimitiveType
ASSERT(count >= 0);
- if (static_cast<unsigned int>(count) + 1 > (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
+ if (static_cast<unsigned int>(count) + 1 >
+ (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
{
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to create a 16-bit looping index buffer for GL_LINE_LOOP, too many indices required.");
+ return gl::OutOfMemory() << "Failed to create a 16-bit looping index buffer for "
+ "GL_LINE_LOOP, too many indices required.";
}
- const unsigned int spaceNeeded = (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short);
+ const unsigned int spaceNeeded =
+ (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short);
gl::Error error = mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT);
if (error.isError())
{
return error;
}
- void* mappedMemory = NULL;
+ void *mappedMemory = nullptr;
unsigned int offset;
error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
if (error.isError())
@@ -1435,40 +1598,41 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
return error;
}
- startIndex = static_cast<unsigned int>(offset) / 2;
- unsigned short *data = reinterpret_cast<unsigned short*>(mappedMemory);
+ startIndex = static_cast<unsigned int>(offset) / 2;
+ unsigned short *data = reinterpret_cast<unsigned short *>(mappedMemory);
switch (type)
{
- case GL_NONE: // Non-indexed draw
- for (int i = 0; i < count; i++)
- {
- data[i] = static_cast<unsigned short>(i);
- }
- data[count] = 0;
- break;
- case GL_UNSIGNED_BYTE:
- 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_UNSIGNED_SHORT:
- 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_UNSIGNED_INT:
- 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();
+ case GL_NONE: // Non-indexed draw
+ for (int i = 0; i < count; i++)
+ {
+ data[i] = static_cast<unsigned short>(i);
+ }
+ data[count] = 0;
+ break;
+ case GL_UNSIGNED_BYTE:
+ 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_UNSIGNED_SHORT:
+ 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_UNSIGNED_INT:
+ 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();
}
error = mLineLoopIB->unmapBuffer();
@@ -1488,22 +1652,31 @@ gl::Error Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indi
mDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, -minIndex, minIndex, count, startIndex, count);
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
template <typename T>
-static gl::Error drawPoints(IDirect3DDevice9* device, GLsizei count, const GLvoid *indices, int minIndex)
+static gl::Error 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;
+ unsigned int indexValue =
+ static_cast<unsigned int>(static_cast<const T *>(indices)[i]) - minIndex;
device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::drawIndexedPoints(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer)
+gl::Error Renderer9::drawIndexedPoints(const gl::Context *context,
+ GLsizei count,
+ GLenum 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.
@@ -1511,10 +1684,10 @@ gl::Error Renderer9::drawIndexedPoints(GLsizei count, GLenum type, const GLvoid
if (elementArrayBuffer)
{
BufferD3D *storage = GetImplAs<BufferD3D>(elementArrayBuffer);
- intptr_t offset = reinterpret_cast<intptr_t>(indices);
+ intptr_t offset = reinterpret_cast<intptr_t>(indices);
- const uint8_t *bufferData = NULL;
- gl::Error error = storage->getData(&bufferData);
+ const uint8_t *bufferData = nullptr;
+ gl::Error error = storage->getData(context, &bufferData);
if (error.isError())
{
return error;
@@ -1525,17 +1698,22 @@ gl::Error Renderer9::drawIndexedPoints(GLsizei count, GLenum type, const GLvoid
switch (type)
{
- case GL_UNSIGNED_BYTE: return drawPoints<GLubyte>(mDevice, count, indices, minIndex);
- case GL_UNSIGNED_SHORT: return drawPoints<GLushort>(mDevice, count, indices, minIndex);
- case GL_UNSIGNED_INT: return drawPoints<GLuint>(mDevice, count, indices, minIndex);
- default: UNREACHABLE(); return gl::Error(GL_INVALID_OPERATION);
+ case GL_UNSIGNED_BYTE:
+ return drawPoints<GLubyte>(mDevice, count, indices, minIndex);
+ case GL_UNSIGNED_SHORT:
+ return drawPoints<GLushort>(mDevice, count, indices, minIndex);
+ case GL_UNSIGNED_INT:
+ return drawPoints<GLuint>(mDevice, count, indices, minIndex);
+ default:
+ UNREACHABLE();
+ return gl::InternalError();
}
}
gl::Error Renderer9::getCountingIB(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
+ if (count <= 65536) // 16-bit indices
{
const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned short);
@@ -1543,29 +1721,21 @@ gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **ou
{
SafeDelete(mCountingIB);
mCountingIB = new StaticIndexBufferInterface(this);
- mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT);
+ ANGLE_TRY(mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT));
- void *mappedMemory = NULL;
- gl::Error error = mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, NULL);
- if (error.isError())
- {
- return error;
- }
+ void *mappedMemory = nullptr;
+ ANGLE_TRY(mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, nullptr));
- unsigned short *data = reinterpret_cast<unsigned short*>(mappedMemory);
+ unsigned short *data = reinterpret_cast<unsigned short *>(mappedMemory);
for (size_t i = 0; i < count; i++)
{
data[i] = static_cast<unsigned short>(i);
}
- error = mCountingIB->unmapBuffer();
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(mCountingIB->unmapBuffer());
}
}
- else if (getRendererExtensions().elementIndexUint)
+ else if (getNativeExtensions().elementIndexUint)
{
const unsigned int spaceNeeded = static_cast<unsigned int>(count) * sizeof(unsigned int);
@@ -1573,59 +1743,53 @@ gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **ou
{
SafeDelete(mCountingIB);
mCountingIB = new StaticIndexBufferInterface(this);
- mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
+ ANGLE_TRY(mCountingIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT));
- void *mappedMemory = NULL;
- gl::Error error = mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, NULL);
- if (error.isError())
- {
- return error;
- }
+ void *mappedMemory = nullptr;
+ ANGLE_TRY(mCountingIB->mapBuffer(spaceNeeded, &mappedMemory, nullptr));
- unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
+ unsigned int *data = reinterpret_cast<unsigned int *>(mappedMemory);
for (unsigned int i = 0; i < count; i++)
{
data[i] = i;
}
- error = mCountingIB->unmapBuffer();
- if (error.isError())
- {
- return error;
- }
+ ANGLE_TRY(mCountingIB->unmapBuffer());
}
}
else
{
- return gl::Error(GL_OUT_OF_MEMORY, "Could not create a counting index buffer for glDrawArraysInstanced.");
+ return gl::OutOfMemory()
+ << "Could not create a counting index buffer for glDrawArraysInstanced.";
}
*outIB = mCountingIB;
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
-gl::Error Renderer9::applyShadersImpl(const gl::Data &data, GLenum /*drawMode*/)
+gl::Error Renderer9::applyShaders(const gl::Context *context, GLenum drawMode)
{
- ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
- const auto &inputLayout = programD3D->getCachedInputLayout();
+ const gl::State &state = context->getContextState().getState();
+ // This method is called single-threaded.
+ ANGLE_TRY(ensureHLSLCompilerInitialized());
- ShaderExecutableD3D *vertexExe = NULL;
- gl::Error error = programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr);
- if (error.isError())
- {
- return error;
- }
+ ProgramD3D *programD3D = GetImplAs<ProgramD3D>(state.getProgram());
+ VertexArray9 *vao = GetImplAs<VertexArray9>(state.getVertexArray());
+ programD3D->updateCachedInputLayout(vao->getCurrentStateSerial(), state);
- const gl::Framebuffer *drawFramebuffer = data.state->getDrawFramebuffer();
- ShaderExecutableD3D *pixelExe = NULL;
- error = programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe);
- if (error.isError())
- {
- return error;
- }
+ ShaderExecutableD3D *vertexExe = nullptr;
+ ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(&vertexExe, nullptr));
+
+ const gl::Framebuffer *drawFramebuffer = state.getDrawFramebuffer();
+ programD3D->updateCachedOutputLayout(context, drawFramebuffer);
+
+ ShaderExecutableD3D *pixelExe = nullptr;
+ ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(&pixelExe, nullptr));
- IDirect3DVertexShader9 *vertexShader = (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
- IDirect3DPixelShader9 *pixelShader = (pixelExe ? GetAs<ShaderExecutable9>(pixelExe)->getPixelShader() : nullptr);
+ IDirect3DVertexShader9 *vertexShader =
+ (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
+ IDirect3DPixelShader9 *pixelShader =
+ (pixelExe ? GetAs<ShaderExecutable9>(pixelExe)->getPixelShader() : nullptr);
if (vertexShader != mAppliedVertexShader)
{
@@ -1652,25 +1816,39 @@ gl::Error Renderer9::applyShadersImpl(const gl::Data &data, GLenum /*drawMode*/)
mAppliedProgramSerial = programSerial;
}
- return gl::Error(GL_NO_ERROR);
+ ANGLE_TRY(applyUniforms(programD3D));
+
+ // Driver uniforms
+ mStateManager.setShaderConstants();
+
+ return gl::NoError();
}
-gl::Error Renderer9::applyUniforms(const ProgramD3D &programD3D,
- GLenum /*drawMode*/,
- const std::vector<D3DUniform *> &uniformArray)
+gl::Error Renderer9::applyUniforms(ProgramD3D *programD3D)
{
+ // Skip updates if we're not dirty. Note that D3D9 cannot have compute.
+ if (!programD3D->areVertexUniformsDirty() && !programD3D->areFragmentUniformsDirty())
+ {
+ return gl::NoError();
+ }
+
+ const auto &uniformArray = programD3D->getD3DUniforms();
+
for (const D3DUniform *targetUniform : uniformArray)
{
- if (!targetUniform->dirty)
+ // Built-in uniforms must be skipped.
+ if (!targetUniform->isReferencedByFragmentShader() &&
+ !targetUniform->isReferencedByVertexShader())
continue;
- GLfloat *f = (GLfloat *)targetUniform->data;
- GLint *i = (GLint *)targetUniform->data;
+ const GLfloat *f = reinterpret_cast<const GLfloat *>(targetUniform->firstNonNullData());
+ const GLint *i = reinterpret_cast<const GLint *>(targetUniform->firstNonNullData());
- switch (targetUniform->type)
+ switch (targetUniform->typeInfo.type)
{
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
+ case GL_SAMPLER_EXTERNAL_OES:
break;
case GL_BOOL:
case GL_BOOL_VEC2:
@@ -1698,22 +1876,22 @@ gl::Error Renderer9::applyUniforms(const ProgramD3D &programD3D,
}
}
- // Driver uniforms
- mStateManager.setShaderConstants();
-
- return gl::Error(GL_NO_ERROR);
+ programD3D->markUniformsClean();
+ return gl::NoError();
}
void Renderer9::applyUniformnfv(const D3DUniform *targetUniform, const GLfloat *v)
{
if (targetUniform->isReferencedByFragmentShader())
{
- mDevice->SetPixelShaderConstantF(targetUniform->psRegisterIndex, v, targetUniform->registerCount);
+ mDevice->SetPixelShaderConstantF(targetUniform->psRegisterIndex, v,
+ targetUniform->registerCount);
}
if (targetUniform->isReferencedByVertexShader())
{
- mDevice->SetVertexShaderConstantF(targetUniform->vsRegisterIndex, v, targetUniform->registerCount);
+ mDevice->SetVertexShaderConstantF(targetUniform->vsRegisterIndex, v,
+ targetUniform->registerCount);
}
}
@@ -1730,7 +1908,7 @@ void Renderer9::applyUniformniv(const D3DUniform *targetUniform, const GLint *v)
vector[i][3] = (GLfloat)v[4 * i + 3];
}
- applyUniformnfv(targetUniform, (GLfloat*)vector);
+ applyUniformnfv(targetUniform, (GLfloat *)vector);
}
void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v)
@@ -1746,18 +1924,19 @@ void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v)
vector[i][3] = (v[4 * i + 3] == GL_FALSE) ? 0.0f : 1.0f;
}
- applyUniformnfv(targetUniform, (GLfloat*)vector);
+ applyUniformnfv(targetUniform, (GLfloat *)vector);
}
-gl::Error Renderer9::clear(const ClearParameters &clearParams,
+gl::Error Renderer9::clear(const gl::Context *context,
+ const ClearParameters &clearParams,
const gl::FramebufferAttachment *colorBuffer,
const gl::FramebufferAttachment *depthStencilBuffer)
{
- if (clearParams.colorClearType != GL_FLOAT)
+ if (clearParams.colorType != GL_FLOAT)
{
// Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0
UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ return gl::InternalError();
}
bool clearColor = clearParams.clearColor[0];
@@ -1765,14 +1944,15 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
{
if (clearParams.clearColor[i] != clearColor)
{
- // Clearing individual buffers other than buffer zero is not supported by Renderer9 and ES 2.0
+ // Clearing individual buffers other than buffer zero is not supported by Renderer9 and
+ // ES 2.0
UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ return gl::InternalError();
}
}
- float depth = gl::clamp01(clearParams.depthClearValue);
- DWORD stencil = clearParams.stencilClearValue & 0x000000FF;
+ float depth = gl::clamp01(clearParams.depthValue);
+ DWORD stencil = clearParams.stencilValue & 0x000000FF;
unsigned int stencilUnmasked = 0x0;
if (clearParams.clearStencil && depthStencilBuffer->getStencilSize() > 0)
@@ -1780,7 +1960,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
ASSERT(depthStencilBuffer != nullptr);
RenderTargetD3D *stencilRenderTarget = nullptr;
- gl::Error error = depthStencilBuffer->getRenderTarget(&stencilRenderTarget);
+ gl::Error error = depthStencilBuffer->getRenderTarget(context, &stencilRenderTarget);
if (error.isError())
{
return error;
@@ -1789,21 +1969,23 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
RenderTarget9 *stencilRenderTarget9 = GetAs<RenderTarget9>(stencilRenderTarget);
ASSERT(stencilRenderTarget9);
- const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(stencilRenderTarget9->getD3DFormat());
+ const d3d9::D3DFormat &d3dFormatInfo =
+ d3d9::GetD3DFormatInfo(stencilRenderTarget9->getD3DFormat());
stencilUnmasked = (0x1 << d3dFormatInfo.stencilBits) - 1;
}
- const bool needMaskedStencilClear = clearParams.clearStencil &&
- (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked;
+ const bool needMaskedStencilClear =
+ clearParams.clearStencil &&
+ (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked;
bool needMaskedColorClear = false;
- D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0);
+ D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0);
if (clearColor)
{
ASSERT(colorBuffer != nullptr);
- RenderTargetD3D *colorRenderTarget = NULL;
- gl::Error error = colorBuffer->getRenderTarget(&colorRenderTarget);
+ RenderTargetD3D *colorRenderTarget = nullptr;
+ gl::Error error = colorBuffer->getRenderTarget(context, &colorRenderTarget);
if (error.isError())
{
return error;
@@ -1812,17 +1994,27 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
RenderTarget9 *colorRenderTarget9 = GetAs<RenderTarget9>(colorRenderTarget);
ASSERT(colorRenderTarget9);
- const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(colorBuffer->getInternalFormat());
- const d3d9::D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(colorRenderTarget9->getD3DFormat());
-
- color = D3DCOLOR_ARGB(gl::unorm<8>((formatInfo.alphaBits == 0 && d3dFormatInfo.alphaBits > 0) ? 1.0f : clearParams.colorFClearValue.alpha),
- gl::unorm<8>((formatInfo.redBits == 0 && d3dFormatInfo.redBits > 0) ? 0.0f : clearParams.colorFClearValue.red),
- gl::unorm<8>((formatInfo.greenBits == 0 && d3dFormatInfo.greenBits > 0) ? 0.0f : clearParams.colorFClearValue.green),
- gl::unorm<8>((formatInfo.blueBits == 0 && d3dFormatInfo.blueBits > 0) ? 0.0f : clearParams.colorFClearValue.blue));
-
- if ((formatInfo.redBits > 0 && !clearParams.colorMaskRed) ||
+ const gl::InternalFormat &formatInfo = *colorBuffer->getFormat().info;
+ const d3d9::D3DFormat &d3dFormatInfo =
+ d3d9::GetD3DFormatInfo(colorRenderTarget9->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));
+
+ if ((formatInfo.redBits > 0 && !clearParams.colorMaskRed) ||
(formatInfo.greenBits > 0 && !clearParams.colorMaskGreen) ||
- (formatInfo.blueBits > 0 && !clearParams.colorMaskBlue) ||
+ (formatInfo.blueBits > 0 && !clearParams.colorMaskBlue) ||
(formatInfo.alphaBits > 0 && !clearParams.colorMaskAlpha))
{
needMaskedColorClear = true;
@@ -1835,7 +2027,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
// State which is altered in only some paths will be flagged dirty in the case that
// that path is taken.
HRESULT hr;
- if (mMaskedClearSavedState == NULL)
+ if (mMaskedClearSavedState == nullptr)
{
hr = mDevice->BeginStateBlock();
ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
@@ -1850,10 +2042,10 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
mDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
mDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
- mDevice->SetPixelShader(NULL);
- mDevice->SetVertexShader(NULL);
+ mDevice->SetPixelShader(nullptr);
+ mDevice->SetVertexShader(nullptr);
mDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
- mDevice->SetStreamSource(0, NULL, 0, 0);
+ 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);
@@ -1862,7 +2054,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
- for(int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
+ for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
{
mDevice->SetStreamSourceFreq(i, 1);
}
@@ -1871,9 +2063,9 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
}
- ASSERT(mMaskedClearSavedState != NULL);
+ ASSERT(mMaskedClearSavedState != nullptr);
- if (mMaskedClearSavedState != NULL)
+ if (mMaskedClearSavedState != nullptr)
{
hr = mMaskedClearSavedState->Capture();
ASSERT(SUCCEEDED(hr));
@@ -1890,11 +2082,10 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
if (clearColor)
{
- mDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
- gl_d3d9::ConvertColorMask(clearParams.colorMaskRed,
- clearParams.colorMaskGreen,
- clearParams.colorMaskBlue,
- clearParams.colorMaskAlpha));
+ mDevice->SetRenderState(
+ D3DRS_COLORWRITEENABLE,
+ gl_d3d9::ConvertColorMask(clearParams.colorMaskRed, clearParams.colorMaskGreen,
+ clearParams.colorMaskBlue, clearParams.colorMaskAlpha));
}
else
{
@@ -1917,8 +2108,8 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
mDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
}
- mDevice->SetPixelShader(NULL);
- mDevice->SetVertexShader(NULL);
+ mDevice->SetPixelShader(nullptr);
+ mDevice->SetVertexShader(nullptr);
mDevice->SetFVF(D3DFVF_XYZRHW);
mDevice->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
mDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
@@ -1928,7 +2119,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
mDevice->SetRenderState(D3DRS_TEXTUREFACTOR, color);
mDevice->SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
- for(int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
+ for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
{
mDevice->SetStreamSourceFreq(i, 1);
}
@@ -1936,7 +2127,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
int renderTargetWidth = mStateManager.getRenderTargetWidth();
int renderTargetHeight = mStateManager.getRenderTargetHeight();
- float quad[4][4]; // A quadrilateral covering the target, aligned to match the edges
+ 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;
@@ -1964,10 +2155,10 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
{
mDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
mDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
- mDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER, color, depth, stencil);
+ mDevice->Clear(0, nullptr, D3DCLEAR_ZBUFFER, color, depth, stencil);
}
- if (mMaskedClearSavedState != NULL)
+ if (mMaskedClearSavedState != nullptr)
{
mMaskedClearSavedState->Apply();
}
@@ -1988,17 +2179,17 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
dxClearFlags |= D3DCLEAR_STENCIL;
}
- mDevice->Clear(0, NULL, dxClearFlags, color, depth, stencil);
+ mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
void Renderer9::markAllStateDirty()
{
- mAppliedRenderTargetSerial = 0;
- mAppliedDepthStencilSerial = 0;
- mDepthStencilInitialized = false;
+ mAppliedRenderTargetSerial = 0;
+ mAppliedDepthStencilSerial = 0;
+ mDepthStencilInitialized = false;
mRenderTargetDescInitialized = false;
mStateManager.forceSetRasterState();
@@ -2021,9 +2212,9 @@ void Renderer9::markAllStateDirty()
mCurPixelTextures[i] = angle::DirtyPointer;
}
- mAppliedIBSerial = 0;
- mAppliedVertexShader = NULL;
- mAppliedPixelShader = NULL;
+ mAppliedIBSerial = 0;
+ mAppliedVertexShader = nullptr;
+ mAppliedPixelShader = nullptr;
mAppliedProgramSerial = 0;
mStateManager.forceSetDXUniformsState();
@@ -2051,6 +2242,10 @@ void Renderer9::releaseDeviceResources()
for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
{
+ if (mNullColorbufferCache[i].buffer)
+ {
+ mNullColorbufferCache[i].buffer->detach(mDisplay->getProxyContext());
+ }
SafeDelete(mNullColorbufferCache[i].buffer);
}
}
@@ -2059,19 +2254,7 @@ void Renderer9::releaseDeviceResources()
bool Renderer9::testDeviceLost()
{
HRESULT status = getDeviceStatusCode();
- bool isLost = FAILED(status);
-
- if (isLost)
- {
- // ensure we note the device loss --
- // we'll probably get this done again by notifyDeviceLost
- // but best to remember it!
- // Note that we don't want to clear the device loss status here
- // -- this needs to be done by resetDevice
- mDeviceLost = true;
- }
-
- return isLost;
+ return FAILED(status);
}
HRESULT Renderer9::getDeviceStatusCode()
@@ -2080,7 +2263,7 @@ HRESULT Renderer9::getDeviceStatusCode()
if (mDeviceEx)
{
- status = mDeviceEx->CheckDeviceState(NULL);
+ status = mDeviceEx->CheckDeviceState(nullptr);
}
else if (mDevice)
{
@@ -2096,16 +2279,16 @@ bool Renderer9::testDeviceResettable()
// 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 != NULL);
- case D3DERR_DEVICEREMOVED:
- ASSERT(mDeviceEx != NULL);
- return isRemovedDeviceResettable();
- default:
- return false;
+ 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;
}
}
@@ -2115,12 +2298,12 @@ bool Renderer9::resetDevice()
D3DPRESENT_PARAMETERS presentParameters = getDefaultPresentParameters();
- HRESULT result = D3D_OK;
- bool lost = testDeviceLost();
+ 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 != NULL || !removedDevice);
+ ASSERT(mDeviceEx != nullptr || !removedDevice);
for (int attempts = 3; lost && attempts > 0; attempts--)
{
@@ -2134,16 +2317,16 @@ bool Renderer9::resetDevice()
}
else if (mDeviceEx)
{
- Sleep(500); // Give the graphics driver some CPU time
- result = mDeviceEx->ResetEx(&presentParameters, NULL);
- lost = testDeviceLost();
+ 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
+ Sleep(100); // Give the graphics driver some CPU time
result = mDevice->TestCooperativeLevel();
}
@@ -2157,13 +2340,13 @@ bool Renderer9::resetDevice()
if (FAILED(result))
{
- ERR("Reset/ResetEx failed multiple times: 0x%08X", result);
+ ERR() << "Reset/ResetEx failed multiple times, " << gl::FmtHR(result);
return false;
}
if (removedDevice && lost)
{
- ERR("Device lost reset failed multiple times");
+ ERR() << "Device lost reset failed multiple times";
return false;
}
@@ -2171,11 +2354,12 @@ bool Renderer9::resetDevice()
if (!removedDevice)
{
// reset device defaults
- initializeDevice();
+ if (initializeDevice().isError())
+ {
+ return false;
+ }
}
- mDeviceLost = false;
-
return true;
}
@@ -2184,15 +2368,16 @@ bool Renderer9::isRemovedDeviceResettable() const
bool success = false;
#if ANGLE_D3D9EX == ANGLE_ENABLED
- IDirect3D9Ex *d3d9Ex = NULL;
- typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex**);
- Direct3DCreate9ExFunc Direct3DCreate9ExPtr = reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
+ 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);
+ success = SUCCEEDED(result);
}
SafeRelease(d3d9Ex);
@@ -2232,20 +2417,22 @@ std::string Renderer9::getRendererDescription() const
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);
+ 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 = { 0 };
- 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;
+ DeviceIdentifier deviceIdentifier = {0};
+ 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;
}
@@ -2260,20 +2447,10 @@ unsigned int Renderer9::getReservedFragmentUniformVectors() const
return d3d9_gl::GetReservedFragmentUniformVectors();
}
-unsigned int Renderer9::getReservedVertexUniformBuffers() const
-{
- return 0;
-}
-
-unsigned int Renderer9::getReservedFragmentUniformBuffers() const
-{
- return 0;
-}
-
bool Renderer9::getShareHandleSupport() const
{
// PIX doesn't seem to support using share handles, so disable them.
- return (mD3d9Ex != NULL) && !gl::DebugAnnotationsActive();
+ return (mD3d9Ex != nullptr) && !gl::DebugAnnotationsActive();
}
int Renderer9::getMajorShaderModel() const
@@ -2298,7 +2475,7 @@ DWORD Renderer9::getCapsDeclTypes() const
D3DPOOL Renderer9::getBufferPool(DWORD usage) const
{
- if (mD3d9Ex != NULL)
+ if (mD3d9Ex != nullptr)
{
return D3DPOOL_DEFAULT;
}
@@ -2313,66 +2490,126 @@ D3DPOOL Renderer9::getBufferPool(DWORD usage) const
return D3DPOOL_DEFAULT;
}
-gl::Error Renderer9::copyImage2D(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
- const gl::Offset &destOffset, TextureStorage *storage, GLint level)
+gl::Error 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.left = sourceRect.x;
+ rect.top = sourceRect.y;
+ rect.right = sourceRect.x + sourceRect.width;
rect.bottom = sourceRect.y + sourceRect.height;
- return mBlit->copy2D(framebuffer, rect, destFormat, destOffset, storage, level);
+ return mBlit->copy2D(context, framebuffer, rect, destFormat, destOffset, storage, level);
}
-gl::Error Renderer9::copyImageCube(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
- const gl::Offset &destOffset, TextureStorage *storage, GLenum target, GLint level)
+gl::Error Renderer9::copyImageCube(const gl::Context *context,
+ const gl::Framebuffer *framebuffer,
+ const gl::Rectangle &sourceRect,
+ GLenum destFormat,
+ const gl::Offset &destOffset,
+ TextureStorage *storage,
+ GLenum target,
+ GLint level)
{
RECT rect;
- rect.left = sourceRect.x;
- rect.top = sourceRect.y;
- rect.right = sourceRect.x + sourceRect.width;
+ rect.left = sourceRect.x;
+ rect.top = sourceRect.y;
+ rect.right = sourceRect.x + sourceRect.width;
rect.bottom = sourceRect.y + sourceRect.height;
- return mBlit->copyCube(framebuffer, rect, destFormat, destOffset, storage, target, level);
+ return mBlit->copyCube(context, framebuffer, rect, destFormat, destOffset, storage, target,
+ level);
}
-gl::Error Renderer9::copyImage3D(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
- const gl::Offset &destOffset, TextureStorage *storage, GLint level)
+gl::Error 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.
UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ return gl::InternalError();
}
-gl::Error Renderer9::copyImage2DArray(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
- const gl::Offset &destOffset, TextureStorage *storage, GLint level)
+gl::Error 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.
UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ return gl::InternalError();
+}
+
+gl::Error Renderer9::copyTexture(const gl::Context *context,
+ const gl::Texture *source,
+ GLint sourceLevel,
+ const gl::Rectangle &sourceRect,
+ GLenum destFormat,
+ const gl::Offset &destOffset,
+ TextureStorage *storage,
+ GLenum destTarget,
+ GLint destLevel,
+ bool unpackFlipY,
+ bool unpackPremultiplyAlpha,
+ bool unpackUnmultiplyAlpha)
+{
+ RECT rect;
+ rect.left = sourceRect.x;
+ rect.top = sourceRect.y;
+ rect.right = sourceRect.x + sourceRect.width;
+ rect.bottom = sourceRect.y + sourceRect.height;
+
+ return mBlit->copyTexture(context, source, sourceLevel, rect, destFormat, destOffset, storage,
+ destTarget, destLevel, unpackFlipY, unpackPremultiplyAlpha,
+ unpackUnmultiplyAlpha);
}
-gl::Error Renderer9::createRenderTarget(int width, int height, GLenum format, GLsizei samples, RenderTargetD3D **outRT)
+gl::Error Renderer9::copyCompressedTexture(const gl::Context *context,
+ const gl::Texture *source,
+ GLint sourceLevel,
+ TextureStorage *storage,
+ GLint destLevel)
+{
+ UNIMPLEMENTED();
+ return gl::InternalError();
+}
+
+gl::Error Renderer9::createRenderTarget(int width,
+ int height,
+ GLenum format,
+ GLsizei samples,
+ RenderTargetD3D **outRT)
{
const d3d9::TextureFormat &d3d9FormatInfo = d3d9::GetTextureFormatInfo(format);
- const gl::TextureCaps &textureCaps = getRendererTextureCaps().get(format);
- GLuint supportedSamples = textureCaps.getNearestSamples(samples);
+ const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format);
+ GLuint supportedSamples = textureCaps.getNearestSamples(samples);
IDirect3DTexture9 *texture = nullptr;
- IDirect3DSurface9 *renderTarget = NULL;
+ IDirect3DSurface9 *renderTarget = nullptr;
if (width > 0 && height > 0)
{
bool requiresInitialization = false;
- HRESULT result = D3DERR_INVALIDCALL;
+ HRESULT result = D3DERR_INVALIDCALL;
- const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(format);
+ 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, NULL);
+ result = mDevice->CreateDepthStencilSurface(
+ width, height, d3d9FormatInfo.renderFormat,
+ gl_d3d9::GetMultisampleType(supportedSamples), 0, FALSE, &renderTarget, nullptr);
}
else
{
@@ -2398,25 +2635,25 @@ gl::Error Renderer9::createRenderTarget(int width, int height, GLenum format, GL
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to create render target, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to create render target, " << gl::FmtHR(result);
}
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 = NULL;
+ // 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, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 255), 0.0f, 0);
+ 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 gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT)
@@ -2424,7 +2661,7 @@ gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTarge
ASSERT(source != nullptr);
RenderTargetD3D *newRT = nullptr;
- gl::Error error = createRenderTarget(source->getWidth(), source->getHeight(),
+ gl::Error error = createRenderTarget(source->getWidth(), source->getHeight(),
source->getInternalFormat(), source->getSamples(), &newRT);
if (error.isError())
{
@@ -2439,31 +2676,16 @@ gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTarge
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to copy render target, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to copy render target, " << gl::FmtHR(result);
}
*outRT = newRT;
- return gl::Error(GL_NO_ERROR);
-}
-
-FramebufferImpl *Renderer9::createFramebuffer(const gl::Framebuffer::Data &data)
-{
- return new Framebuffer9(data, this);
-}
-
-ShaderImpl *Renderer9::createShader(const gl::Shader::Data &data)
-{
- return new ShaderD3D(data);
+ return gl::NoError();
}
-ProgramImpl *Renderer9::createProgram(const gl::Program::Data &data)
-{
- return new ProgramD3D(data, this);
-}
-
-gl::Error Renderer9::loadExecutable(const void *function,
+gl::Error Renderer9::loadExecutable(const uint8_t *function,
size_t length,
- ShaderType type,
+ gl::ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable)
@@ -2473,10 +2695,10 @@ gl::Error Renderer9::loadExecutable(const void *function,
switch (type)
{
- case SHADER_VERTEX:
+ case gl::SHADER_VERTEX:
{
- IDirect3DVertexShader9 *vshader = NULL;
- gl::Error error = createVertexShader((DWORD*)function, length, &vshader);
+ IDirect3DVertexShader9 *vshader = nullptr;
+ gl::Error error = createVertexShader((DWORD *)function, length, &vshader);
if (error.isError())
{
return error;
@@ -2484,10 +2706,10 @@ gl::Error Renderer9::loadExecutable(const void *function,
*outExecutable = new ShaderExecutable9(function, length, vshader);
}
break;
- case SHADER_PIXEL:
+ case gl::SHADER_FRAGMENT:
{
- IDirect3DPixelShader9 *pshader = NULL;
- gl::Error error = createPixelShader((DWORD*)function, length, &pshader);
+ IDirect3DPixelShader9 *pshader = nullptr;
+ gl::Error error = createPixelShader((DWORD *)function, length, &pshader);
if (error.isError())
{
return error;
@@ -2495,41 +2717,45 @@ gl::Error Renderer9::loadExecutable(const void *function,
*outExecutable = new ShaderExecutable9(function, length, pshader);
}
break;
- default:
- UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ default:
+ UNREACHABLE();
+ return gl::InternalError();
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
}
gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
- ShaderType type,
+ gl::ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
bool separatedOutputBuffers,
- const D3DCompilerWorkarounds &workarounds,
+ const angle::CompilerWorkaroundsD3D &workarounds,
ShaderExecutableD3D **outExectuable)
{
// Transform feedback is not supported in ES2 or D3D9
ASSERT(streamOutVaryings.empty());
- const char *profileType = NULL;
+ std::stringstream profileStream;
+
switch (type)
{
- case SHADER_VERTEX:
- profileType = "vs";
- break;
- case SHADER_PIXEL:
- profileType = "ps";
- break;
- default:
- UNREACHABLE();
- return gl::Error(GL_INVALID_OPERATION);
+ case gl::SHADER_VERTEX:
+ profileStream << "vs";
+ break;
+ case gl::SHADER_FRAGMENT:
+ profileStream << "ps";
+ break;
+ default:
+ UNREACHABLE();
+ return gl::InternalError();
}
- unsigned int profileMajorVersion = (getMajorShaderModel() >= 3) ? 3 : 2;
- unsigned int profileMinorVersion = 0;
- std::string profile = FormatString("%s_%u_%u", profileType, profileMajorVersion, profileMinorVersion);
+
+ profileStream << "_" << ((getMajorShaderModel() >= 3) ? 3 : 2);
+ profileStream << "_"
+ << "0";
+
+ std::string profile = profileStream.str();
UINT flags = ANGLE_COMPILE_OPTIMIZATION_LEVEL;
@@ -2551,31 +2777,35 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
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.
+ // 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, "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 = NULL;
+ ID3DBlob *binary = nullptr;
std::string debugInfo;
- gl::Error error = mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, NULL, &binary, &debugInfo);
+ gl::Error error = mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, nullptr,
+ &binary, &debugInfo);
if (error.isError())
{
return 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.
+ // 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 = NULL;
- return gl::Error(GL_NO_ERROR);
+ *outExectuable = nullptr;
+ return gl::NoError();
}
- error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
- streamOutVaryings, separatedOutputBuffers, outExectuable);
+ error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
+ binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers,
+ outExectuable);
SafeRelease(binary);
if (error.isError())
@@ -2588,7 +2818,12 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
(*outExectuable)->appendDebugInfo(debugInfo);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
+}
+
+gl::Error Renderer9::ensureHLSLCompilerInitialized()
+{
+ return mCompiler.ensureInitialized();
}
UniformStorageD3D *Renderer9::createUniformStorage(size_t storageSize)
@@ -2603,7 +2838,7 @@ gl::Error Renderer9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *des
D3DPOOL Renderer9::getTexturePool(DWORD usage) const
{
- if (mD3d9Ex != NULL)
+ if (mD3d9Ex != nullptr)
{
return D3DPOOL_DEFAULT;
}
@@ -2618,7 +2853,9 @@ D3DPOOL Renderer9::getTexturePool(DWORD usage) const
return D3DPOOL_DEFAULT;
}
-gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged)
+gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
+ IDirect3DSurface9 *source,
+ bool fromManaged)
{
ASSERT(source && dest);
@@ -2630,28 +2867,34 @@ gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurfac
source->GetDesc(&desc);
IDirect3DSurface9 *surf = 0;
- result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surf, NULL);
+ result = mDevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format,
+ D3DPOOL_SYSTEMMEM, &surf, nullptr);
if (SUCCEEDED(result))
{
- Image9::copyLockableSurfaces(surf, source);
- result = mDevice->UpdateSurface(surf, NULL, dest, NULL);
+ ANGLE_TRY(Image9::copyLockableSurfaces(surf, source));
+ result = mDevice->UpdateSurface(surf, nullptr, dest, nullptr);
SafeRelease(surf);
}
}
else
{
endScene();
- result = mDevice->StretchRect(source, NULL, dest, NULL, D3DTEXF_NONE);
+ result = mDevice->StretchRect(source, nullptr, dest, nullptr, D3DTEXF_NONE);
}
if (FAILED(result))
{
ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
- return gl::Error(GL_OUT_OF_MEMORY, "Failed to blit internal texture, result: 0x%X.", result);
+ return gl::OutOfMemory() << "Failed to blit internal texture, " << gl::FmtHR(result);
}
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
+}
+
+RendererClass Renderer9::getRendererClass() const
+{
+ return RENDERER_D3D9;
}
ImageD3D *Renderer9::createImage()
@@ -2659,18 +2902,34 @@ ImageD3D *Renderer9::createImage()
return new Image9(this);
}
-gl::Error Renderer9::generateMipmap(ImageD3D *dest, ImageD3D *src)
+gl::Error Renderer9::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src)
{
Image9 *src9 = GetAs<Image9>(src);
Image9 *dst9 = GetAs<Image9>(dest);
return Image9::generateMipmap(dst9, src9);
}
-gl::Error Renderer9::generateMipmapsUsingD3D(TextureStorage *storage,
- const gl::TextureState &textureState)
+gl::Error Renderer9::generateMipmapUsingD3D(const gl::Context *context,
+ TextureStorage *storage,
+ const gl::TextureState &textureState)
{
UNREACHABLE();
- return gl::Error(GL_NO_ERROR);
+ return gl::NoError();
+}
+
+gl::Error Renderer9::copyImage(const gl::Context *context,
+ ImageD3D *dest,
+ ImageD3D *source,
+ const gl::Rectangle &sourceRect,
+ 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, sourceRect, destOffset, unpackFlipY,
+ unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}
TextureStorage *Renderer9::createTextureStorage2D(SwapChainD3D *swapChain)
@@ -2679,59 +2938,83 @@ TextureStorage *Renderer9::createTextureStorage2D(SwapChainD3D *swapChain)
return new TextureStorage9_2D(this, swapChain9);
}
-TextureStorage *Renderer9::createTextureStorageEGLImage(EGLImageD3D *eglImage)
+TextureStorage *Renderer9::createTextureStorageEGLImage(EGLImageD3D *eglImage,
+ RenderTargetD3D *renderTargetD3D)
+{
+ return new TextureStorage9_EGLImage(this, eglImage, GetAs<RenderTarget9>(renderTargetD3D));
+}
+
+TextureStorage *Renderer9::createTextureStorageExternal(
+ egl::Stream *stream,
+ const egl::Stream::GLTextureDescription &desc)
{
- return new TextureStorage9_EGLImage(this, eglImage);
+ UNIMPLEMENTED();
+ return nullptr;
}
-TextureStorage *Renderer9::createTextureStorage2D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels, bool hintLevelZeroOnly)
+TextureStorage *Renderer9::createTextureStorage2D(GLenum internalformat,
+ bool renderTarget,
+ GLsizei width,
+ GLsizei height,
+ int levels,
+ bool hintLevelZeroOnly)
{
return new TextureStorage9_2D(this, internalformat, renderTarget, width, height, levels);
}
-TextureStorage *Renderer9::createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly)
+TextureStorage *Renderer9::createTextureStorageCube(GLenum internalformat,
+ bool renderTarget,
+ int size,
+ int levels,
+ bool hintLevelZeroOnly)
{
- return new TextureStorage9_Cube(this, internalformat, renderTarget, size, levels, hintLevelZeroOnly);
+ return new TextureStorage9_Cube(this, internalformat, renderTarget, size, levels,
+ hintLevelZeroOnly);
}
-TextureStorage *Renderer9::createTextureStorage3D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels)
+TextureStorage *Renderer9::createTextureStorage3D(GLenum internalformat,
+ bool renderTarget,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ int levels)
{
// 3D textures are not supported by the D3D9 backend.
UNREACHABLE();
- return NULL;
+ return nullptr;
}
-TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels)
+TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat,
+ bool renderTarget,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ int levels)
{
// 2D array textures are not supported by the D3D9 backend.
UNREACHABLE();
- return NULL;
+ return nullptr;
}
-TextureImpl *Renderer9::createTexture(GLenum target)
+TextureStorage *Renderer9::createTextureStorage2DMultisample(GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ int levels,
+ int samples,
+ bool fixedSampleLocations)
{
- switch(target)
- {
- case GL_TEXTURE_2D: return new TextureD3D_2D(this);
- case GL_TEXTURE_CUBE_MAP: return new TextureD3D_Cube(this);
- default: UNREACHABLE();
- }
+ // 2D multisampled textures are not supported by the D3D9 backend.
+ UNREACHABLE();
return NULL;
}
-RenderbufferImpl *Renderer9::createRenderbuffer()
-{
- RenderbufferD3D *renderbuffer = new RenderbufferD3D(this);
- return renderbuffer;
-}
-
bool Renderer9::getLUID(LUID *adapterLuid) const
{
adapterLuid->HighPart = 0;
- adapterLuid->LowPart = 0;
+ adapterLuid->LowPart = 0;
if (mD3d9Ex)
{
@@ -2752,6 +3035,40 @@ GLenum Renderer9::getVertexComponentType(gl::VertexFormatType vertexFormatType)
return d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType).componentType;
}
+gl::ErrorOrResult<unsigned int> Renderer9::getVertexSpaceRequired(const gl::VertexAttribute &attrib,
+ const gl::VertexBinding &binding,
+ GLsizei count,
+ GLsizei instances) const
+{
+ if (!attrib.enabled)
+ {
+ return 16u;
+ }
+
+ gl::VertexFormatType vertexFormatType = gl::GetVertexFormatType(attrib, GL_FLOAT);
+ const d3d9::VertexFormat &d3d9VertexInfo =
+ d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType);
+
+ 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);
+ }
+
+ if (d3d9VertexInfo.outputElementSize > std::numeric_limits<unsigned int>::max() / elementCount)
+ {
+ return gl::OutOfMemory() << "New vertex buffer size would result in an overflow.";
+ }
+
+ return static_cast<unsigned int>(d3d9VertexInfo.outputElementSize) * elementCount;
+}
+
void Renderer9::generateCaps(gl::Caps *outCaps,
gl::TextureCapsMap *outTextureCaps,
gl::Extensions *outExtensions,
@@ -2761,31 +3078,11 @@ void Renderer9::generateCaps(gl::Caps *outCaps,
outExtensions, outLimitations);
}
-WorkaroundsD3D Renderer9::generateWorkarounds() const
+angle::WorkaroundsD3D Renderer9::generateWorkarounds() const
{
return d3d9::GenerateWorkarounds();
}
-void Renderer9::createAnnotator()
-{
- mAnnotator = new DebugAnnotator9();
-}
-
-gl::Error Renderer9::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
-{
- // TODO(jmadill): faster way?
- for (size_t samplerIndex = rangeStart; samplerIndex < rangeEnd; samplerIndex++)
- {
- gl::Error error = setTexture(samplerType, static_cast<int>(samplerIndex), nullptr);
- if (error.isError())
- {
- return error;
- }
- }
-
- return gl::Error(GL_NO_ERROR);
-}
-
egl::Error Renderer9::getEGLDevice(DeviceImpl **device)
{
if (mEGLDevice == nullptr)
@@ -2803,14 +3100,211 @@ egl::Error Renderer9::getEGLDevice(DeviceImpl **device)
}
*device = static_cast<DeviceImpl *>(mEGLDevice);
- return egl::Error(EGL_SUCCESS);
+ return egl::NoError();
}
Renderer9::CurSamplerState::CurSamplerState()
- : forceSet(true),
- baseLevel(std::numeric_limits<size_t>::max()),
- samplerState()
+ : forceSet(true), baseLevel(std::numeric_limits<size_t>::max()), samplerState()
+{
+}
+
+gl::Error Renderer9::genericDrawElements(const gl::Context *context,
+ GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const void *indices,
+ GLsizei instances)
+{
+ const auto &data = context->getContextState();
+ gl::Program *program = context->getGLState().getProgram();
+ ASSERT(program != nullptr);
+ ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
+ bool usesPointSize = programD3D->usesPointSize();
+
+ programD3D->updateSamplerMapping();
+
+ if (!applyPrimitiveType(mode, count, usesPointSize))
+ {
+ return gl::NoError();
+ }
+
+ ANGLE_TRY(updateState(context, mode));
+ ANGLE_TRY(applyTextures(context));
+ ANGLE_TRY(applyShaders(context, mode));
+
+ if (!skipDraw(data.getState(), mode))
+ {
+ ANGLE_TRY(drawElementsImpl(context, mode, count, type, indices, instances));
+ }
+
+ return gl::NoError();
+}
+
+gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
+ GLenum mode,
+ GLint first,
+ GLsizei count,
+ GLsizei instances)
+{
+ gl::Program *program = context->getGLState().getProgram();
+ ASSERT(program != nullptr);
+ ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
+ bool usesPointSize = programD3D->usesPointSize();
+
+ programD3D->updateSamplerMapping();
+
+ if (!applyPrimitiveType(mode, count, usesPointSize))
+ {
+ return gl::NoError();
+ }
+
+ 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->getGLState(), mode))
+ {
+ ANGLE_TRY(drawArraysImpl(context, mode, first, count, instances));
+ }
+
+ return gl::NoError();
+}
+
+FramebufferImpl *Renderer9::createDefaultFramebuffer(const gl::FramebufferState &state)
{
+ return new Framebuffer9(state, this);
}
+gl::Version Renderer9::getMaxSupportedESVersion() const
+{
+ return gl::Version(2, 0);
+}
+
+gl::Error Renderer9::clearRenderTarget(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 gl::NoError();
}
+
+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.
+gl::Error Renderer9::applyTextures(const gl::Context *context, gl::SamplerType shaderType)
+{
+ const auto &glState = context->getGLState();
+ const auto &caps = context->getCaps();
+ ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
+
+ ASSERT(!programD3D->isSamplerMappingDirty());
+
+ // TODO(jmadill): Use the Program's sampler bindings.
+ const auto &completeTextures = glState.getCompleteTextureCache();
+
+ unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType);
+ for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
+ {
+ GLint textureUnit = programD3D->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(setTexture(context, shaderType, samplerIndex, texture));
+ }
+ else
+ {
+ GLenum 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
+ size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? caps.maxTextureImageUnits
+ : caps.maxVertexTextureImageUnits;
+
+ // TODO(jmadill): faster way?
+ for (size_t samplerIndex = samplerRange; samplerIndex < samplerCount; samplerIndex++)
+ {
+ ANGLE_TRY(setTexture(context, shaderType, static_cast<int>(samplerIndex), nullptr));
+ }
+
+ return gl::NoError();
+}
+
+gl::Error Renderer9::applyTextures(const gl::Context *context)
+{
+ ANGLE_TRY(applyTextures(context, gl::SAMPLER_VERTEX));
+ ANGLE_TRY(applyTextures(context, gl::SAMPLER_PIXEL));
+ return gl::NoError();
+}
+
+} // namespace rx