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