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