Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  22  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28
  29 #if USE(3D_GRAPHICS)
  30 #include "Extensions3DOpenGLCommon.h"
  31
  32 #include "ANGLEWebKitBridge.h"
  33 #include "GraphicsContext3D.h"
  34
  35 #if PLATFORM(BLACKBERRY)
  36 #include <BlackBerryPlatformLog.h>
  37 #endif
  38
  39 #if USE(OPENGL_ES_2)
  40 #include "OpenGLESShims.h"
  41 #include <GLES2/gl2.h>
  42 #include <GLES2/gl2ext.h>
  43 #elif PLATFORM(MAC)
  44 #include <OpenGL/gl.h>
  45 #elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN) || PLATFORM(NIX)
  46 #include "OpenGLShims.h"
  47 #endif
  48
  49 #include <wtf/MainThread.h>
  50 #include <wtf/Vector.h>
  51
  52 namespace WebCore {
  53
  54 Extensions3DOpenGLCommon::Extensions3DOpenGLCommon(GraphicsContext3D* context)
  55     : m_initializedAvailableExtensions(false)
  56     , m_context(context)
  57     , m_isNVIDIA(false)
  58     , m_isAMD(false)
  59     , m_isIntel(false)
  60     , m_maySupportMultisampling(true)
  61     , m_requiresBuiltInFunctionEmulation(false)
  62 {
  63     m_vendor = String(reinterpret_cast<const char*>(::glGetString(GL_VENDOR)));
  64
  65     Vector<String> vendorComponents;
  66     m_vendor.lower().split(' ', vendorComponents);
  67     if (vendorComponents.contains("nvidia"))
  68         m_isNVIDIA = true;
  69     if (vendorComponents.contains("ati") || vendorComponents.contains("amd"))
  70         m_isAMD = true;
  71     if (vendorComponents.contains("intel"))
  72         m_isIntel = true;
  73
  74 #if PLATFORM(MAC)
  75     if (m_isAMD || m_isIntel)
  76         m_requiresBuiltInFunctionEmulation = true;
  77
  78     // Currently in Mac we only allow multisampling if the vendor is NVIDIA,
  79     // or if the vendor is AMD/ATI and the system is 10.7.2 and above.
  80
  81     bool systemSupportsMultisampling = true;
  82 #if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED < 1080
  83     ASSERT(isMainThread());
  84     static SInt32 version;
  85     if (!version) {
  86         if (Gestalt(gestaltSystemVersion, &version) != noErr)
  87             systemSupportsMultisampling = false;
  88     }
  89     // See https://bugs.webkit.org/show_bug.cgi?id=77922 for more details
  90     if (systemSupportsMultisampling)
  91         systemSupportsMultisampling = version >= 0x1072;
  92 #endif // SNOW_LEOPARD and LION
  93
  94     if (m_isAMD && !systemSupportsMultisampling)
  95         m_maySupportMultisampling = false;
  96 #endif
  97 }
  98
  99 Extensions3DOpenGLCommon::~Extensions3DOpenGLCommon()
 100 {
 101 }
 102
 103 bool Extensions3DOpenGLCommon::supports(const String& name)
 104 {
 105     if (!m_initializedAvailableExtensions)
 106         initializeAvailableExtensions();
 107
 108     return supportsExtension(name);
 109 }
 110
 111 void Extensions3DOpenGLCommon::ensureEnabled(const String& name)
 112 {
 113     if (name == "GL_OES_standard_derivatives") {
 114         // Enable support in ANGLE (if not enabled already)
 115         ANGLEWebKitBridge& compiler = m_context->m_compiler;
 116         ShBuiltInResources ANGLEResources = compiler.getResources();
 117         if (!ANGLEResources.OES_standard_derivatives) {
 118             ANGLEResources.OES_standard_derivatives = 1;
 119             compiler.setResources(ANGLEResources);
 120         }
 121     } else if (name == "GL_EXT_draw_buffers") {
 122         // Enable support in ANGLE (if not enabled already)
 123         ANGLEWebKitBridge& compiler = m_context->m_compiler;
 124         ShBuiltInResources ANGLEResources = compiler.getResources();
 125         if (!ANGLEResources.EXT_draw_buffers) {
 126             ANGLEResources.EXT_draw_buffers = 1;
 127             m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &ANGLEResources.MaxDrawBuffers);
 128             compiler.setResources(ANGLEResources);
 129         }
 130     }
 131 }
 132
 133 bool Extensions3DOpenGLCommon::isEnabled(const String& name)
 134 {
 135     if (name == "GL_OES_standard_derivatives") {
 136         ANGLEWebKitBridge& compiler = m_context->m_compiler;
 137         return compiler.getResources().OES_standard_derivatives;
 138     }
 139     return supports(name);
 140 }
 141
 142 int Extensions3DOpenGLCommon::getGraphicsResetStatusARB()
 143 {
 144     return GraphicsContext3D::NO_ERROR;
 145 }
 146
 147 String Extensions3DOpenGLCommon::getTranslatedShaderSourceANGLE(Platform3DObject shader)
 148 {
 149     ASSERT(shader);
 150     int GLshaderType;
 151     ANGLEShaderType shaderType;
 152
 153     ANGLEWebKitBridge& compiler = m_context->m_compiler;
 154
 155     m_context->getShaderiv(shader, GraphicsContext3D::SHADER_TYPE, &GLshaderType);
 156
 157     if (GLshaderType == GraphicsContext3D::VERTEX_SHADER)
 158         shaderType = SHADER_TYPE_VERTEX;
 159     else if (GLshaderType == GraphicsContext3D::FRAGMENT_SHADER)
 160         shaderType = SHADER_TYPE_FRAGMENT;
 161     else
 162         return ""; // Invalid shader type.
 163
 164     HashMap<Platform3DObject, GraphicsContext3D::ShaderSourceEntry>::iterator result = m_context->m_shaderSourceMap.find(shader);
 165
 166     if (result == m_context->m_shaderSourceMap.end())
 167         return "";
 168
 169     GraphicsContext3D::ShaderSourceEntry& entry = result->value;
 170
 171     String translatedShaderSource;
 172     String shaderInfoLog;
 173     int extraCompileOptions = SH_MAP_LONG_VARIABLE_NAMES | SH_CLAMP_INDIRECT_ARRAY_BOUNDS | SH_UNFOLD_SHORT_CIRCUIT | SH_ENFORCE_PACKING_RESTRICTIONS;
 174
 175     if (m_requiresBuiltInFunctionEmulation)
 176         extraCompileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
 177
 178     Vector<ANGLEShaderSymbol> symbols;
 179     bool isValid = compiler.compileShaderSource(entry.source.utf8().data(), shaderType, translatedShaderSource, shaderInfoLog, symbols, extraCompileOptions);
 180
 181     entry.log = shaderInfoLog;
 182     entry.isValid = isValid;
 183
 184     size_t numSymbols = symbols.size();
 185     for (size_t i = 0; i < numSymbols; ++i) {
 186         ANGLEShaderSymbol shaderSymbol = symbols[i];
 187         GraphicsContext3D::SymbolInfo symbolInfo(shaderSymbol.dataType, shaderSymbol.size, shaderSymbol.mappedName, shaderSymbol.precision, shaderSymbol.staticUse);
 188         entry.symbolMap(shaderSymbol.symbolType).set(shaderSymbol.name, symbolInfo);
 189     }
 190
 191     if (!isValid)
 192         return "";
 193
 194     return translatedShaderSource;
 195 }
 196
 197 void Extensions3DOpenGLCommon::initializeAvailableExtensions()
 198 {
 199     String extensionsString = getExtensions();
 200     Vector<String> availableExtensions;
 201     extensionsString.split(" ", availableExtensions);
 202     for (size_t i = 0; i < availableExtensions.size(); ++i)
 203         m_availableExtensions.add(availableExtensions[i]);
 204     m_initializedAvailableExtensions = true;
 205 }
 206
 207 void Extensions3DOpenGLCommon::readnPixelsEXT(int, int, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, GC3Dsizei, void *)
 208 {
 209     m_context->synthesizeGLError(GL_INVALID_OPERATION);
 210 }
 211
 212 void Extensions3DOpenGLCommon::getnUniformfvEXT(GC3Duint, int, GC3Dsizei, float *)
 213 {
 214     m_context->synthesizeGLError(GL_INVALID_OPERATION);
 215 }
 216
 217 void Extensions3DOpenGLCommon::getnUniformivEXT(GC3Duint, int, GC3Dsizei, int *)
 218 {
 219     m_context->synthesizeGLError(GL_INVALID_OPERATION);
 220 }
 221
 222 } // namespace WebCore
 223
 224 #endif // USE(3D_GRAPHICS)