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

   1 //
   2 // Copyright (c) 2012-2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // Renderer.cpp: Implements EGL dependencies for creating and destroying Renderer instances.
   8
   9 #include "libGLESv2/main.h"
  10 #include "libGLESv2/Program.h"
  11 #include "libGLESv2/renderer/Renderer.h"
  12 #include "common/utilities.h"
  13 #include "third_party/trace_event/trace_event.h"
  14 #include "libGLESv2/Shader.h"
  15
  16 #if defined (ANGLE_ENABLE_D3D9)
  17 #include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
  18 #endif // ANGLE_ENABLE_D3D9
  19
  20 #if defined (ANGLE_ENABLE_D3D11)
  21 #include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
  22 #endif // ANGLE_ENABLE_D3D11
  23
  24 #if defined (ANGLE_TEST_CONFIG)
  25 #define ANGLE_DEFAULT_D3D11 1
  26 #endif
  27
  28 #if !defined(ANGLE_DEFAULT_D3D11)
  29 // Enables use of the Direct3D 11 API for a default display, when available
  30 #define ANGLE_DEFAULT_D3D11 0
  31 #endif
  32
  33 #include <EGL/eglext.h>
  34
  35 namespace rx
  36 {
  37
  38 Renderer::Renderer(egl::Display *display)
  39     : mDisplay(display),
  40       mCapsInitialized(false),
  41       mWorkaroundsInitialized(false),
  42       mCurrentClientVersion(2)
  43 {
  44 }
  45
  46 Renderer::~Renderer()
  47 {
  48 }
  49
  50 const gl::Caps &Renderer::getRendererCaps() const
  51 {
  52     if (!mCapsInitialized)
  53     {
  54         generateCaps(&mCaps, &mTextureCaps, &mExtensions);
  55         mCapsInitialized = true;
  56     }
  57
  58     return mCaps;
  59 }
  60
  61 const gl::TextureCapsMap &Renderer::getRendererTextureCaps() const
  62 {
  63     if (!mCapsInitialized)
  64     {
  65         generateCaps(&mCaps, &mTextureCaps, &mExtensions);
  66         mCapsInitialized = true;
  67     }
  68
  69     return mTextureCaps;
  70 }
  71
  72 const gl::Extensions &Renderer::getRendererExtensions() const
  73 {
  74     if (!mCapsInitialized)
  75     {
  76         generateCaps(&mCaps, &mTextureCaps, &mExtensions);
  77         mCapsInitialized = true;
  78     }
  79
  80     return mExtensions;
  81 }
  82
  83 const Workarounds &Renderer::getWorkarounds() const
  84 {
  85     if (!mWorkaroundsInitialized)
  86     {
  87         mWorkarounds = generateWorkarounds();
  88         mWorkaroundsInitialized = true;
  89     }
  90
  91     return mWorkarounds;
  92 }
  93
  94 typedef Renderer *(*CreateRendererFunction)(egl::Display*, EGLNativeDisplayType, EGLint);
  95
  96 template <typename RendererType>
  97 Renderer *CreateRenderer(egl::Display *display, EGLNativeDisplayType nativeDisplay, EGLint requestedDisplayType)
  98 {
  99     return new RendererType(display, nativeDisplay, requestedDisplayType);
 100 }
 101
 102 }
 103
 104 extern "C"
 105 {
 106
 107 rx::Renderer *glCreateRenderer(egl::Display *display, EGLNativeDisplayType nativeDisplay, EGLint requestedDisplayType)
 108 {
 109     std::vector<rx::CreateRendererFunction> rendererCreationFunctions;
 110
 111 #   if defined(ANGLE_ENABLE_D3D11)
 112         if (nativeDisplay == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
 113             nativeDisplay == EGL_D3D11_ONLY_DISPLAY_ANGLE ||
 114             requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE ||
 115             requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE)
 116         {
 117             rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer11>);
 118         }
 119 #   endif
 120
 121 #   if defined(ANGLE_ENABLE_D3D9)
 122         if (nativeDisplay == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
 123             requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE)
 124         {
 125             rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer9>);
 126         }
 127 #   endif
 128
 129     if (nativeDisplay != EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE &&
 130         nativeDisplay != EGL_D3D11_ONLY_DISPLAY_ANGLE &&
 131         requestedDisplayType == EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE)
 132     {
 133         // The default display is requested, try the D3D9 and D3D11 renderers, order them using
 134         // the definition of ANGLE_DEFAULT_D3D11
 135 #       if ANGLE_DEFAULT_D3D11
 136 #           if defined(ANGLE_ENABLE_D3D11)
 137                 rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer11>);
 138 #           endif
 139 #           if defined(ANGLE_ENABLE_D3D9)
 140                 rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer9>);
 141 #           endif
 142 #       else
 143 #           if defined(ANGLE_ENABLE_D3D9)
 144                 rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer9>);
 145 #           endif
 146 #           if defined(ANGLE_ENABLE_D3D11)
 147                 rendererCreationFunctions.push_back(rx::CreateRenderer<rx::Renderer11>);
 148 #           endif
 149 #       endif
 150     }
 151
 152     for (size_t i = 0; i < rendererCreationFunctions.size(); i++)
 153     {
 154         rx::Renderer *renderer = rendererCreationFunctions[i](display, nativeDisplay, requestedDisplayType);
 155         if (renderer->initialize() == EGL_SUCCESS)
 156         {
 157             return renderer;
 158         }
 159         else
 160         {
 161             // Failed to create the renderer, try the next
 162             SafeDelete(renderer);
 163         }
 164     }
 165
 166     return NULL;
 167 }
 168
 169 void glDestroyRenderer(rx::Renderer *renderer)
 170 {
 171     delete renderer;
 172 }
 173
 174 }