Remove remaining PLATFORM(CHROMIUM)-guarded code in WebCore
[WebKit-https.git] / 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(QT)
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_isNVIDIA || (m_isAMD && systemSupportsMultisampling))
95         m_maySupportMultisampling = true;
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;
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);
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)