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