The Tor Browser: comparison gfx/angle/src/libGLESv2/renderer/Renderer.cpp

--1:000000000000
+:6b7a5393852e
+#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 <EGL/eglext.h>
+#include "libGLESv2/main.h"
+#include "libGLESv2/Program.h"
+#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/Renderer9.h"
+#include "libGLESv2/renderer/Renderer11.h"
+#include "libGLESv2/utilities.h"
+#if !defined(ANGLE_ENABLE_D3D11)
+// Enables use of the Direct3D 11 API for a default display, when available
+#define ANGLE_ENABLE_D3D11 0
+#endif
+#define ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES \
+{                                            \
+TEXT("d3dcompiler_47.dll"),              \
+TEXT("d3dcompiler_46.dll"),              \
+TEXT("d3dcompiler_43.dll")               \
+}
+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<pCompileFunc>(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<pD3DCompile>(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, EGLNativeDisplayType displayId)
+{
+rx::Renderer *renderer = NULL;
+EGLint status = EGL_BAD_ALLOC;
+if (ANGLE_ENABLE_D3D11 ||
+displayId == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
+displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
+{
+renderer = new rx::Renderer11(display, hDc);
+if (renderer)
+{
+status = renderer->initialize();
+}
+if (status == EGL_SUCCESS)
+{
+return renderer;
+}
+else if (displayId == EGL_D3D11_ONLY_DISPLAY_ANGLE)
+{
+return NULL;
+}
+// Failed to create a D3D11 renderer, try creating a D3D9 renderer
+delete renderer;
+}
+bool softwareDevice = (displayId == EGL_SOFTWARE_DISPLAY_ANGLE);
+renderer = new rx::Renderer9(display, hDc, softwareDevice);
+if (renderer)
+{
+status = renderer->initialize();
+}
+if (status == EGL_SUCCESS)
+{
+return renderer;
+}
+return NULL;
+}
+void glDestroyRenderer(rx::Renderer *renderer)
+{
+delete renderer;
+}
+}

The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/renderer/Renderer.cpp

gfx/angle/src/libGLESv2/renderer/Renderer.cpp