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