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