Source/WebCore: [WebGL] Implement ANGLE_instanced_arrays
[WebKit-https.git] / Source / WebCore / html / canvas / WebGLRenderingContext.h
1 /*
2  * Copyright (C) 2009, 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef WebGLRenderingContext_h
27 #define WebGLRenderingContext_h
28
29 #include "ActiveDOMObject.h"
30 #include "CanvasRenderingContext.h"
31 #include "DrawingBuffer.h"
32 #include "GraphicsContext3D.h"
33 #include "ImageBuffer.h"
34 #include "Timer.h"
35 #include "WebGLGetInfo.h"
36
37 #include <memory>
38 #include <runtime/Float32Array.h>
39 #include <runtime/Int32Array.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace WebCore {
43
44 class ANGLEInstancedArrays;
45 class EXTDrawBuffers;
46 class EXTTextureFilterAnisotropic;
47 class HTMLImageElement;
48 class HTMLVideoElement;
49 class ImageBuffer;
50 class ImageData;
51 class IntSize;
52 class OESStandardDerivatives;
53 class OESTextureFloat;
54 class OESTextureFloatLinear;
55 class OESTextureHalfFloat;
56 class OESTextureHalfFloatLinear;
57 class OESVertexArrayObject;
58 class OESElementIndexUint;
59 class WebGLActiveInfo;
60 class WebGLBuffer;
61 class WebGLContextGroup;
62 class WebGLContextObject;
63 class WebGLCompressedTextureATC;
64 class WebGLCompressedTexturePVRTC;
65 class WebGLCompressedTextureS3TC;
66 class WebGLContextAttributes;
67 class WebGLDebugRendererInfo;
68 class WebGLDebugShaders;
69 class WebGLDepthTexture;
70 class WebGLExtension;
71 class WebGLFramebuffer;
72 class WebGLLoseContext;
73 class WebGLObject;
74 class WebGLProgram;
75 class WebGLRenderbuffer;
76 class WebGLShader;
77 class WebGLSharedObject;
78 class WebGLShaderPrecisionFormat;
79 class WebGLTexture;
80 class WebGLUniformLocation;
81 class WebGLVertexArrayObjectOES;
82
83 typedef int ExceptionCode;
84
85 class WebGLRenderingContext : public CanvasRenderingContext, public ActiveDOMObject {
86 public:
87     static OwnPtr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);
88     virtual ~WebGLRenderingContext();
89
90     virtual bool is3d() const override { return true; }
91     virtual bool isAccelerated() const override { return true; }
92
93     int drawingBufferWidth() const;
94     int drawingBufferHeight() const;
95
96     void activeTexture(GC3Denum texture, ExceptionCode&);
97     void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
98     void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);
99     void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);
100     void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);
101     void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);
102     void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);
103     void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
104     void blendEquation(GC3Denum mode);
105     void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
106     void blendFunc(GC3Denum sfactor, GC3Denum dfactor);
107     void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);
108
109     void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);
110     void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);
111     void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);
112     void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);
113     void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);
114
115     GC3Denum checkFramebufferStatus(GC3Denum target);
116     void clear(GC3Dbitfield mask);
117     void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
118     void clearDepth(GC3Dfloat);
119     void clearStencil(GC3Dint);
120     void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
121     void compileShader(WebGLShader*, ExceptionCode&);
122
123     void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
124                               GC3Dsizei height, GC3Dint border, ArrayBufferView* data);
125     void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
126                                  GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);
127
128     void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);
129     void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
130
131     PassRefPtr<WebGLBuffer> createBuffer();
132     PassRefPtr<WebGLFramebuffer> createFramebuffer();
133     PassRefPtr<WebGLProgram> createProgram();
134     PassRefPtr<WebGLRenderbuffer> createRenderbuffer();
135     PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);
136     PassRefPtr<WebGLTexture> createTexture();
137
138     void cullFace(GC3Denum mode);
139
140     void deleteBuffer(WebGLBuffer*);
141     void deleteFramebuffer(WebGLFramebuffer*);
142     void deleteProgram(WebGLProgram*);
143     void deleteRenderbuffer(WebGLRenderbuffer*);
144     void deleteShader(WebGLShader*);
145     void deleteTexture(WebGLTexture*);
146
147     void depthFunc(GC3Denum);
148     void depthMask(GC3Dboolean);
149     void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);
150     void detachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
151     void disable(GC3Denum cap);
152     void disableVertexAttribArray(GC3Duint index, ExceptionCode&);
153     void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);
154     void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);
155
156     void enable(GC3Denum cap);
157     void enableVertexAttribArray(GC3Duint index, ExceptionCode&);
158     void finish();
159     void flush();
160     void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);
161     void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);
162     void frontFace(GC3Denum mode);
163     void generateMipmap(GC3Denum target);
164
165     PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);
166     PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);
167     bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&, ExceptionCode&);
168     GC3Dint getAttribLocation(WebGLProgram*, const String& name);
169     WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
170     PassRefPtr<WebGLContextAttributes> getContextAttributes();
171     GC3Denum getError();
172     WebGLExtension* getExtension(const String& name);
173     WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);
174     WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);
175     WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);
176     String getProgramInfoLog(WebGLProgram*, ExceptionCode&);
177     WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
178     WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);
179     String getShaderInfoLog(WebGLShader*, ExceptionCode&);
180     PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);
181     String getShaderSource(WebGLShader*, ExceptionCode&);
182     Vector<String> getSupportedExtensions();
183     WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
184     WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);
185     PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);
186     WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);
187     long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
188
189     void hint(GC3Denum target, GC3Denum mode);
190     GC3Dboolean isBuffer(WebGLBuffer*);
191     bool isContextLost() const;
192     GC3Dboolean isEnabled(GC3Denum cap);
193     GC3Dboolean isFramebuffer(WebGLFramebuffer*);
194     GC3Dboolean isProgram(WebGLProgram*);
195     GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);
196     GC3Dboolean isShader(WebGLShader*);
197     GC3Dboolean isTexture(WebGLTexture*);
198
199     void lineWidth(GC3Dfloat);
200     void linkProgram(WebGLProgram*, ExceptionCode&);
201     void pixelStorei(GC3Denum pname, GC3Dint param);
202     void polygonOffset(GC3Dfloat factor, GC3Dfloat units);
203     void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&);
204     void releaseShaderCompiler();
205     void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
206     void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);
207     void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
208     void shaderSource(WebGLShader*, const String&, ExceptionCode&);
209     void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);
210     void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);
211     void stencilMask(GC3Duint);
212     void stencilMaskSeparate(GC3Denum face, GC3Duint mask);
213     void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
214     void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
215
216     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
217                     GC3Dsizei width, GC3Dsizei height, GC3Dint border,
218                     GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);
219     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
220                     GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);
221     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
222                     GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);
223     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
224                     GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);
225 #if ENABLE(VIDEO)
226     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
227                     GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);
228 #endif
229
230     void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
231     void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
232
233     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
234                        GC3Dsizei width, GC3Dsizei height,
235                        GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);
236     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
237                        GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);
238     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
239                        GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);
240     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
241                        GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);
242 #if ENABLE(VIDEO)
243     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
244                        GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);
245 #endif
246
247     void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);
248     void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
249     void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
250     void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);
251     void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
252     void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
253     void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);
254     void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
255     void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
256     void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);
257     void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
258     void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
259     void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);
260     void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
261     void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
262     void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);
263     void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
264     void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
265     void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);
266     void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
267     void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
268     void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);
269     void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
270     void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
271     void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
272     void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
273     void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
274     void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
275     void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
276     void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
277
278     void useProgram(WebGLProgram*, ExceptionCode&);
279     void validateProgram(WebGLProgram*, ExceptionCode&);
280
281     void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
282     void vertexAttrib1fv(GC3Duint index, Float32Array* values);
283     void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
284     void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
285     void vertexAttrib2fv(GC3Duint index, Float32Array* values);
286     void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
287     void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
288     void vertexAttrib3fv(GC3Duint index, Float32Array* values);
289     void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
290     void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
291     void vertexAttrib4fv(GC3Duint index, Float32Array* values);
292     void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
293     void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
294                              GC3Dsizei stride, long long offset, ExceptionCode&);
295
296     void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
297
298     // WEBKIT_lose_context support
299     enum LostContextMode {
300         // Lost context occurred at the graphics system level.
301         RealLostContext,
302
303         // Lost context provoked by WEBKIT_lose_context.
304         SyntheticLostContext
305     };
306     void forceLostContext(LostContextMode);
307     void forceRestoreContext();
308     void loseContextImpl(LostContextMode);
309
310     GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
311     WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
312 #if USE(ACCELERATED_COMPOSITING)
313     virtual PlatformLayer* platformLayer() const override;
314 #endif
315
316     void reshape(int width, int height);
317
318     void markLayerComposited();
319     virtual void paintRenderingResultsToCanvas() override;
320     virtual PassRefPtr<ImageData> paintRenderingResultsToImageData();
321
322     void removeSharedObject(WebGLSharedObject*);
323     void removeContextObject(WebGLContextObject*);
324     
325     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
326
327     // ANGLE_instanced_arrays extension functions.
328     void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
329     void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset, GC3Dsizei primcount);
330     void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
331
332 private:
333     friend class EXTDrawBuffers;
334     friend class WebGLFramebuffer;
335     friend class WebGLObject;
336     friend class OESVertexArrayObject;
337     friend class WebGLDebugShaders;
338     friend class WebGLCompressedTextureATC;
339     friend class WebGLCompressedTexturePVRTC;
340     friend class WebGLCompressedTextureS3TC;
341     friend class WebGLRenderingContextErrorMessageCallback;
342     friend class WebGLVertexArrayObjectOES;
343
344     WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
345     void initializeNewContext();
346     void setupFlags();
347
348     // ActiveDOMObject
349     virtual bool hasPendingActivity() const override;
350     virtual void stop() override;
351
352     void addSharedObject(WebGLSharedObject*);
353     void addContextObject(WebGLContextObject*);
354     void detachAndRemoveAllObjects();
355
356     void destroyGraphicsContext3D();
357     void markContextChanged();
358     void cleanupAfterGraphicsCall(bool changed)
359     {
360         if (changed)
361             markContextChanged();
362     }
363
364     // Query whether it is built on top of compliant GLES2 implementation.
365     bool isGLES2Compliant() { return m_isGLES2Compliant; }
366     // Query if the GL implementation is NPOT strict.
367     bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
368     // Query if the GL implementation generates errors on out-of-bounds buffer accesses.
369     bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }
370     // Query if the GL implementation initializes textures/renderbuffers to 0.
371     bool isResourceSafe() { return m_isResourceSafe; }
372     // Query if depth_stencil buffer is supported.
373     bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
374
375     // Helper to return the size in bytes of OpenGL data types
376     // like GL_FLOAT, GL_INT, etc.
377     unsigned int sizeInBytes(GC3Denum type);
378
379     // Basic validation of count and offset against number of elements in element array buffer
380     bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
381
382     // Conservative but quick index validation
383     bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired);
384
385     // Precise but slow index validation -- only done if conservative checks fail
386     bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);
387     bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);
388
389     bool validateWebGLObject(const char*, WebGLObject*);
390
391     bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
392     bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements);
393
394     // Adds a compressed texture format.
395     void addCompressedTextureFormat(GC3Denum);
396
397     PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, int deviceScaleFactor);
398
399 #if ENABLE(VIDEO)
400     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);
401 #endif
402
403     RefPtr<GraphicsContext3D> m_context;
404     RefPtr<WebGLContextGroup> m_contextGroup;
405
406     // Optional structure for rendering to a DrawingBuffer, instead of directly
407     // to the back-buffer of m_context.
408     RefPtr<DrawingBuffer> m_drawingBuffer;
409
410     // Dispatches a context lost event once it is determined that one is needed.
411     // This is used both for synthetic and real context losses. For real ones, it's
412     // likely that there's no JavaScript on the stack, but that might be dependent
413     // on how exactly the platform discovers that the context was lost. For better
414     // portability we always defer the dispatch of the event.
415     Timer<WebGLRenderingContext> m_dispatchContextLostEventTimer;
416     bool m_restoreAllowed;
417     Timer<WebGLRenderingContext> m_restoreTimer;
418
419     bool m_needsUpdate;
420     bool m_markedCanvasDirty;
421     HashSet<WebGLContextObject*> m_contextObjects;
422
423     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
424     RefPtr<WebGLBuffer> m_boundArrayBuffer;
425     
426     RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
427     RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
428     void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> arrayObject)
429     {
430         if (arrayObject)
431             m_boundVertexArrayObject = arrayObject;
432         else
433             m_boundVertexArrayObject = m_defaultVertexArrayObject;
434     }
435     
436     class VertexAttribValue {
437     public:
438         VertexAttribValue()
439         {
440             initValue();
441         }
442         
443         void initValue()
444         {
445             value[0] = 0.0f;
446             value[1] = 0.0f;
447             value[2] = 0.0f;
448             value[3] = 1.0f;
449         }
450         
451         GC3Dfloat value[4];
452     };
453     Vector<VertexAttribValue> m_vertexAttribValue;
454     unsigned m_maxVertexAttribs;
455     RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;
456     long m_vertexAttrib0BufferSize;
457     GC3Dfloat m_vertexAttrib0BufferValue[4];
458     bool m_forceAttrib0BufferRefill;
459     bool m_vertexAttrib0UsedBefore;
460
461     RefPtr<WebGLProgram> m_currentProgram;
462     RefPtr<WebGLFramebuffer> m_framebufferBinding;
463     RefPtr<WebGLRenderbuffer> m_renderbufferBinding;
464     struct TextureUnitState {
465         RefPtr<WebGLTexture> texture2DBinding;
466         RefPtr<WebGLTexture> textureCubeMapBinding;
467     };
468     Vector<TextureUnitState> m_textureUnits;
469     unsigned long m_activeTextureUnit;
470
471     RefPtr<WebGLTexture> m_blackTexture2D;
472     RefPtr<WebGLTexture> m_blackTextureCubeMap;
473
474     Vector<GC3Denum> m_compressedTextureFormats;
475
476     // Fixed-size cache of reusable image buffers for video texImage2D calls.
477     class LRUImageBufferCache {
478     public:
479         LRUImageBufferCache(int capacity);
480         // The pointer returned is owned by the image buffer map.
481         ImageBuffer* imageBuffer(const IntSize& size);
482     private:
483         void bubbleToFront(int idx);
484         std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;
485         int m_capacity;
486     };
487     LRUImageBufferCache m_generatedImageCache;
488
489     GC3Dint m_maxTextureSize;
490     GC3Dint m_maxCubeMapTextureSize;
491     GC3Dint m_maxRenderbufferSize;
492     GC3Dint m_maxViewportDims[2];
493     GC3Dint m_maxTextureLevel;
494     GC3Dint m_maxCubeMapTextureLevel;
495
496     GC3Dint m_maxDrawBuffers;
497     GC3Dint m_maxColorAttachments;
498     GC3Denum m_backDrawBuffer;
499     bool m_drawBuffersWebGLRequirementsChecked;
500     bool m_drawBuffersSupported;
501
502     GC3Dint m_packAlignment;
503     GC3Dint m_unpackAlignment;
504     bool m_unpackFlipY;
505     bool m_unpackPremultiplyAlpha;
506     GC3Denum m_unpackColorspaceConversion;
507     bool m_contextLost;
508     LostContextMode m_contextLostMode;
509     GraphicsContext3D::Attributes m_attributes;
510
511     bool m_layerCleared;
512     GC3Dfloat m_clearColor[4];
513     bool m_scissorEnabled;
514     GC3Dfloat m_clearDepth;
515     GC3Dint m_clearStencil;
516     GC3Dboolean m_colorMask[4];
517     GC3Dboolean m_depthMask;
518
519     bool m_stencilEnabled;
520     GC3Duint m_stencilMask, m_stencilMaskBack;
521     GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.
522     GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;
523
524     bool m_isGLES2Compliant;
525     bool m_isGLES2NPOTStrict;
526     bool m_isErrorGeneratedOnOutOfBoundsAccesses;
527     bool m_isResourceSafe;
528     bool m_isDepthStencilSupported;
529     bool m_isRobustnessEXTSupported;
530
531     bool m_synthesizedErrorsToConsole;
532     int m_numGLErrorsToConsoleAllowed;
533
534     // Enabled extension objects.
535     OwnPtr<EXTDrawBuffers> m_extDrawBuffers;
536     OwnPtr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
537     OwnPtr<OESTextureFloat> m_oesTextureFloat;
538     OwnPtr<OESTextureFloatLinear> m_oesTextureFloatLinear;
539     OwnPtr<OESTextureHalfFloat> m_oesTextureHalfFloat;
540     OwnPtr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;
541     OwnPtr<OESStandardDerivatives> m_oesStandardDerivatives;
542     OwnPtr<OESVertexArrayObject> m_oesVertexArrayObject;
543     OwnPtr<OESElementIndexUint> m_oesElementIndexUint;
544     OwnPtr<WebGLLoseContext> m_webglLoseContext;
545     OwnPtr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
546     OwnPtr<WebGLDebugShaders> m_webglDebugShaders;
547     OwnPtr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
548     OwnPtr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
549     OwnPtr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
550     OwnPtr<WebGLDepthTexture> m_webglDepthTexture;
551     OwnPtr<ANGLEInstancedArrays> m_angleInstancedArrays;
552
553     // Helpers for getParameter and others
554     WebGLGetInfo getBooleanParameter(GC3Denum);
555     WebGLGetInfo getBooleanArrayParameter(GC3Denum);
556     WebGLGetInfo getFloatParameter(GC3Denum);
557     WebGLGetInfo getIntParameter(GC3Denum);
558     WebGLGetInfo getUnsignedIntParameter(GC3Denum);
559     WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);
560     WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);
561
562     // Clear the backbuffer if it was composited since the last operation.
563     // clearMask is set to the bitfield of any clear that would happen anyway at this time
564     // and the function returns true if that clear is now unnecessary.
565     bool clearIfComposited(GC3Dbitfield clearMask = 0);
566
567     // Helper to restore state that clearing the framebuffer may destroy.
568     void restoreStateAfterClear();
569
570     void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
571     void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
572     void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
573     void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
574
575     void checkTextureCompleteness(const char*, bool);
576
577     void createFallbackBlackTextures1x1();
578
579     // Helper function for copyTex{Sub}Image, check whether the internalformat
580     // and the color buffer format of the current bound framebuffer combination
581     // is valid.
582     bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,
583                                                         GC3Denum colorBufferFormat);
584
585     // Helper function to get the bound framebuffer's color buffer format.
586     GC3Denum getBoundFramebufferColorFormat();
587
588     // Helper function to get the bound framebuffer's width.
589     int getBoundFramebufferWidth();
590
591     // Helper function to get the bound framebuffer's height.
592     int getBoundFramebufferHeight();
593
594     // Helper function to verify limits on the length of uniform and attribute locations.
595     bool validateLocationLength(const char* functionName, const String&);
596
597     // Helper function to check if size is non-negative.
598     // Generate GL error and return false for negative inputs; otherwise, return true.
599     bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);
600
601     // Helper function to check if all characters in the string belong to the
602     // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
603     bool validateString(const char* functionName, const String&);
604
605     // Helper function to check target and texture bound to the target.
606     // Generate GL errors and return 0 if target is invalid or texture bound is
607     // null.  Otherwise, return the texture bound to the target.
608     WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
609
610     // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
611     // Generates GL error and returns false if parameters are invalid.
612     bool validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level);
613
614     // Helper function to check input level for functions {copy}Tex{Sub}Image.
615     // Generates GL error and returns false if level is invalid.
616     bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
617
618     enum TexFuncValidationFunctionType {
619         NotTexSubImage2D,
620         TexSubImage2D,
621     };
622
623     enum TexFuncValidationSourceType {
624         SourceArrayBufferView,
625         SourceImageData,
626         SourceHTMLImageElement,
627         SourceHTMLCanvasElement,
628         SourceHTMLVideoElement,
629     };
630
631     // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.
632     // Otherwise, it would return quickly without doing other work.
633     bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
634         GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);
635
636     // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
637     // Generates GL error and returns false if parameters are invalid.
638     bool validateTexFuncParameters(const char* functionName,
639                                    TexFuncValidationFunctionType,
640                                    GC3Denum target, GC3Dint level,
641                                    GC3Denum internalformat,
642                                    GC3Dsizei width, GC3Dsizei height, GC3Dint border,
643                                    GC3Denum format, GC3Denum type);
644
645     enum NullDisposition {
646         NullAllowed,
647         NullNotAllowed
648     };
649
650     // Helper function to validate that the given ArrayBufferView
651     // is of the correct type and contains enough data for the texImage call.
652     // Generates GL error and returns false if parameters are invalid.
653     bool validateTexFuncData(const char* functionName, GC3Dint level,
654                              GC3Dsizei width, GC3Dsizei height,
655                              GC3Denum format, GC3Denum type,
656                              ArrayBufferView* pixels,
657                              NullDisposition);
658
659     // Helper function to validate a given texture format is settable as in
660     // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and
661     // copyTexSubImage2D.
662     // Generates GL error and returns false if the format is not settable.
663     bool validateSettableTexFormat(const char* functionName, GC3Denum format);
664
665     // Helper function to validate compressed texture data is correct size
666     // for the given format and dimensions.
667     bool validateCompressedTexFuncData(const char* functionName,
668                                        GC3Dsizei width, GC3Dsizei height,
669                                        GC3Denum format, ArrayBufferView* pixels);
670
671     // Helper function for validating compressed texture formats.
672     bool validateCompressedTexFormat(GC3Denum format);
673
674     // Helper function to validate compressed texture dimensions are valid for
675     // the given format.
676     bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);
677
678     // Helper function to validate compressed texture dimensions are valid for
679     // the given format.
680     bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
681                                             GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
682
683     // Helper function to validate mode for draw{Arrays/Elements}.
684     bool validateDrawMode(const char* functionName, GC3Denum);
685
686     // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
687     bool validateStencilSettings(const char* functionName);
688
689     // Helper function to validate stencil func.
690     bool validateStencilFunc(const char* functionName, GC3Denum);
691
692     // Helper function for texParameterf and texParameteri.
693     void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);
694
695     // Helper function to print GL errors to console.
696     void printGLErrorToConsole(const String&);
697     void printGLWarningToConsole(const char* function, const char* reason);
698
699     // Helper function to print warnings to console. Currently
700     // used only to warn about use of obsolete functions.
701     void printWarningToConsole(const String&);
702
703     // Helper function to validate input parameters for framebuffer functions.
704     // Generate GL error if parameters are illegal.
705     bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment);
706
707     // Helper function to validate blend equation mode.
708     bool validateBlendEquation(const char* functionName, GC3Denum);
709
710     // Helper function to validate blend func factors.
711     bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
712
713     // Helper function to validate a GL capability.
714     bool validateCapability(const char* functionName, GC3Denum);
715
716     // Helper function to validate input parameters for uniform functions.
717     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);
718     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);
719     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);
720     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);
721     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);
722
723     // Helper function to validate parameters for bufferData.
724     // Return the current bound buffer to target, or 0 if parameters are invalid.
725     WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
726
727     // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.
728     bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);
729
730     // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.
731     bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);
732
733 #if ENABLE(VIDEO)
734     // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.
735     bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);
736 #endif
737
738     // Helper functions for vertexAttribNf{v}.
739     void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);
740     void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);
741     void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);
742
743     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
744     // Return false if caller should return without further processing.
745     bool deleteObject(WebGLObject*);
746
747     // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.
748     // If the object has already been deleted, set deleted to true upon return.
749     // Return false if caller should return without further processing.
750     bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);
751
752     // Helpers for simulating vertexAttrib0
753     void initVertexAttrib0();
754     bool simulateVertexAttrib0(GC3Dsizei numVertex);
755     void restoreStatesAfterVertexAttrib0Simulation();
756
757     void dispatchContextLostEvent(Timer<WebGLRenderingContext>*);
758     // Helper for restoration after context lost.
759     void maybeRestoreContext(Timer<WebGLRenderingContext>*);
760
761     // Determine if we are running privileged code in the browser, for example,
762     // a Safari or Chrome extension.
763     bool allowPrivilegedExtensions() const;
764
765     enum ConsoleDisplayPreference {
766         DisplayInConsole,
767         DontDisplayInConsole
768     };
769
770     // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message
771     // to the JavaScript console.
772     void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
773
774     String ensureNotNull(const String&) const;
775
776     // Enable or disable stencil test based on user setting and
777     // whether the current FBO has a stencil buffer.
778     void applyStencilTest();
779
780     // Helper for enabling or disabling a capability.
781     void enableOrDisable(GC3Denum capability, bool enable);
782
783     // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
784     IntSize clampedCanvasSize();
785
786     // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.
787     // Later, return the cached value.
788     GC3Dint getMaxDrawBuffers();
789     GC3Dint getMaxColorAttachments();
790
791     void setBackDrawBuffer(GC3Denum);
792
793     void restoreCurrentFramebuffer();
794     void restoreCurrentTexture2D();
795
796     // Check if EXT_draw_buffers extension is supported and if it satisfies the WebGL requirements.
797     bool supportsDrawBuffers();
798
799     friend class WebGLStateRestorer;
800 };
801
802 } // namespace WebCore
803
804 #endif