From 710ad8ce1bd5d01ce048851d210ac3831ca17dde Mon Sep 17 00:00:00 2001 From: Andrew Knight Date: Wed, 3 Apr 2013 19:57:09 +0300 Subject: Upgrade ANGLE to DX11 Proto Upgrades ANGLE to dx11proto (dx11-MRT-support tag), which splits out support for DirectX9 & DirectX11. The DX9 codepath is used by default; CONFIG+=angle_d3d11 must be passed to the ANGLE project to build for DX11. Existing patches to ANGLE have been updated (or removed if no longer needed), and a patch has been added to make DX9/DX11 codepaths mutually exclusive. Change-Id: Ibe13befadb94f04883eca449d0ee1f0da955ff92 Reviewed-by: Oswald Buddenhagen Reviewed-by: Gunnar Sletta Reviewed-by: Friedemann Kleint Reviewed-by: Axel Waggershauser --- .../angle/src/libGLESv2/renderer/Renderer.cpp | 201 +++++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp (limited to 'src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp') diff --git a/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp new file mode 100644 index 0000000000..41cdb8b278 --- /dev/null +++ b/src/3rdparty/angle/src/libGLESv2/renderer/Renderer.cpp @@ -0,0 +1,201 @@ +#include "precompiled.h" +// +// Copyright (c) 2012-2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// Renderer.cpp: Implements EGL dependencies for creating and destroying Renderer instances. + +#include "libGLESv2/main.h" +#include "libGLESv2/Program.h" +#include "libGLESv2/renderer/Renderer.h" +#if defined(ANGLE_ENABLE_D3D11) +# include "libGLESv2/renderer/Renderer11.h" +# define D3DERR_OUTOFVIDEOMEMORY MAKE_HRESULT( 1, 0x876, 380 ) +#else +# include "libGLESv2/renderer/Renderer9.h" +#endif +#include "libGLESv2/utilities.h" + +#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL) +#define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3 +#endif + +namespace rx +{ + +Renderer::Renderer(egl::Display *display) : mDisplay(display) +{ + mD3dCompilerModule = NULL; + mD3DCompileFunc = NULL; +} + +Renderer::~Renderer() +{ + if (mD3dCompilerModule) + { + FreeLibrary(mD3dCompilerModule); + mD3dCompilerModule = NULL; + } +} + +bool Renderer::initializeCompiler() +{ +#if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES) + // Find a D3DCompiler module that had already been loaded based on a predefined list of versions. + static TCHAR* d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES; + + for (size_t i = 0; i < ArraySize(d3dCompilerNames); ++i) + { + if (GetModuleHandleEx(0, d3dCompilerNames[i], &mD3dCompilerModule)) + { + break; + } + } +#else + // Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with. + mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL); +#endif // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES + + if (!mD3dCompilerModule) + { + ERR("No D3D compiler module found - aborting!\n"); + return false; + } + + mD3DCompileFunc = reinterpret_cast(GetProcAddress(mD3dCompilerModule, "D3DCompile")); + ASSERT(mD3DCompileFunc); + + return mD3DCompileFunc != NULL; +} + +// Compiles HLSL code into executable binaries +ShaderBlob *Renderer::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, const char *profile, UINT optimizationFlags, bool alternateFlags) +{ + if (!hlsl) + { + return NULL; + } + + HRESULT result = S_OK; + UINT flags = 0; + std::string sourceText; + if (gl::perfActive()) + { + flags |= D3DCOMPILE_DEBUG; + +#ifdef NDEBUG + flags |= optimizationFlags; +#else + flags |= D3DCOMPILE_SKIP_OPTIMIZATION; +#endif + + std::string sourcePath = getTempPath(); + sourceText = std::string("#line 2 \"") + sourcePath + std::string("\"\n\n") + std::string(hlsl); + writeFile(sourcePath.c_str(), sourceText.c_str(), sourceText.size()); + } + else + { + flags |= optimizationFlags; + sourceText = hlsl; + } + + // 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. + const static UINT extraFlags[] = + { + 0, + D3DCOMPILE_AVOID_FLOW_CONTROL, + D3DCOMPILE_PREFER_FLOW_CONTROL + }; + + const static char * const extraFlagNames[] = + { + "default", + "avoid flow control", + "prefer flow control" + }; + + int attempts = alternateFlags ? ArraySize(extraFlags) : 1; + pD3DCompile compileFunc = reinterpret_cast(mD3DCompileFunc); + for (int i = 0; i < attempts; ++i) + { + ID3DBlob *errorMessage = NULL; + ID3DBlob *binary = NULL; + + result = compileFunc(hlsl, strlen(hlsl), gl::g_fakepath, NULL, NULL, + "main", profile, flags | extraFlags[i], 0, &binary, &errorMessage); + if (errorMessage) + { + const char *message = (const char*)errorMessage->GetBufferPointer(); + + infoLog.appendSanitized(message); + TRACE("\n%s", hlsl); + TRACE("\n%s", message); + + errorMessage->Release(); + errorMessage = NULL; + } + + if (SUCCEEDED(result)) + { + return (ShaderBlob*)binary; + } + else + { + if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY) + { + return gl::error(GL_OUT_OF_MEMORY, (ShaderBlob*) NULL); + } + + infoLog.append("Warning: D3D shader compilation failed with "); + infoLog.append(extraFlagNames[i]); + infoLog.append(" flags."); + if (i + 1 < attempts) + { + infoLog.append(" Retrying with "); + infoLog.append(extraFlagNames[i + 1]); + infoLog.append(".\n"); + } + } + } + + return NULL; +} + +} + +extern "C" +{ + +rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, bool softwareDevice) +{ + rx::Renderer *renderer = NULL; + EGLint status = EGL_BAD_ALLOC; + +#if defined(ANGLE_ENABLE_D3D11) + renderer = new rx::Renderer11(display, hDc); +#else + renderer = new rx::Renderer9(display, hDc, softwareDevice); +#endif + + if (renderer) + { + status = renderer->initialize(); + } + + if (status == EGL_SUCCESS) + { + return renderer; + } + + return NULL; +} + +void glDestroyRenderer(rx::Renderer *renderer) +{ + delete renderer; +} + +} -- cgit v1.2.3