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