Fixed WebGL compile errors on Windows.
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsContext3D.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 GraphicsContext3D_h
27 #define GraphicsContext3D_h
28
29 #include "GraphicsTypes3D.h"
30 #include "Image.h"
31 #include "IntRect.h"
32 #include "KURL.h"
33 #include "PlatformLayer.h"
34 #include <wtf/HashMap.h>
35 #include <wtf/ListHashSet.h>
36 #include <wtf/Noncopyable.h>
37 #include <wtf/OwnArrayPtr.h>
38 #include <wtf/PassOwnArrayPtr.h>
39 #include <wtf/RefCounted.h>
40 #include <wtf/text/WTFString.h>
41
42 // FIXME: Find a better way to avoid the name confliction for NO_ERROR.
43 #if PLATFORM(WIN) || (PLATFORM(QT) && OS(WINDOWS))
44 #undef NO_ERROR
45 #elif PLATFORM(GTK)
46 // This define is from the X11 headers, but it's used below, so we must undefine it.
47 #undef VERSION
48 #endif
49
50 #if PLATFORM(MAC) || PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(EFL) || PLATFORM(BLACKBERRY) || PLATFORM(WIN)
51 #include "ANGLEWebKitBridge.h"
52 #endif
53
54 #if PLATFORM(MAC)
55 #include <wtf/RetainPtr.h>
56 OBJC_CLASS CALayer;
57 OBJC_CLASS WebGLLayer;
58 #elif PLATFORM(QT)
59 QT_BEGIN_NAMESPACE
60 class QPainter;
61 class QRect;
62 class QGLWidget;
63 class QGLContext;
64 class QOpenGLContext;
65 class QSurface;
66 QT_END_NAMESPACE
67 #elif PLATFORM(GTK) || PLATFORM(EFL)
68 typedef unsigned int GLuint;
69 #endif
70
71 #if PLATFORM(MAC)
72 typedef struct _CGLContextObject *CGLContextObj;
73
74 typedef CGLContextObj PlatformGraphicsContext3D;
75 #elif PLATFORM(QT)
76 typedef QOpenGLContext* PlatformGraphicsContext3D;
77 typedef QSurface* PlatformGraphicsSurface3D;
78 #else
79 typedef void* PlatformGraphicsContext3D;
80 typedef void* PlatformGraphicsSurface3D;
81 #endif
82
83 // These are currently the same among all implementations.
84 const PlatformGraphicsContext3D NullPlatformGraphicsContext3D = 0;
85 const Platform3DObject NullPlatform3DObject = 0;
86
87 namespace WebCore {
88 class DrawingBuffer;
89 class Extensions3D;
90 #if USE(OPENGL_ES_2)
91 class Extensions3DOpenGLES;
92 #else
93 class Extensions3DOpenGL;
94 #endif
95 #if PLATFORM(QT)
96 class Extensions3DQt;
97 #endif
98 class HostWindow;
99 class Image;
100 class ImageBuffer;
101 class ImageSource;
102 class ImageData;
103 class IntRect;
104 class IntSize;
105 #if USE(CAIRO)
106 class PlatformContextCairo;
107 #elif PLATFORM(BLACKBERRY)
108 class GraphicsContext;
109 #endif
110
111 struct ActiveInfo {
112     String name;
113     GC3Denum type;
114     GC3Dint size;
115 };
116
117 class GraphicsContext3DPrivate;
118
119 class GraphicsContext3D : public RefCounted<GraphicsContext3D> {
120 public:
121     enum {
122         DEPTH_BUFFER_BIT = 0x00000100,
123         STENCIL_BUFFER_BIT = 0x00000400,
124         COLOR_BUFFER_BIT = 0x00004000,
125         POINTS = 0x0000,
126         LINES = 0x0001,
127         LINE_LOOP = 0x0002,
128         LINE_STRIP = 0x0003,
129         TRIANGLES = 0x0004,
130         TRIANGLE_STRIP = 0x0005,
131         TRIANGLE_FAN = 0x0006,
132         ZERO = 0,
133         ONE = 1,
134         SRC_COLOR = 0x0300,
135         ONE_MINUS_SRC_COLOR = 0x0301,
136         SRC_ALPHA = 0x0302,
137         ONE_MINUS_SRC_ALPHA = 0x0303,
138         DST_ALPHA = 0x0304,
139         ONE_MINUS_DST_ALPHA = 0x0305,
140         DST_COLOR = 0x0306,
141         ONE_MINUS_DST_COLOR = 0x0307,
142         SRC_ALPHA_SATURATE = 0x0308,
143         FUNC_ADD = 0x8006,
144         BLEND_EQUATION = 0x8009,
145         BLEND_EQUATION_RGB = 0x8009,
146         BLEND_EQUATION_ALPHA = 0x883D,
147         FUNC_SUBTRACT = 0x800A,
148         FUNC_REVERSE_SUBTRACT = 0x800B,
149         BLEND_DST_RGB = 0x80C8,
150         BLEND_SRC_RGB = 0x80C9,
151         BLEND_DST_ALPHA = 0x80CA,
152         BLEND_SRC_ALPHA = 0x80CB,
153         CONSTANT_COLOR = 0x8001,
154         ONE_MINUS_CONSTANT_COLOR = 0x8002,
155         CONSTANT_ALPHA = 0x8003,
156         ONE_MINUS_CONSTANT_ALPHA = 0x8004,
157         BLEND_COLOR = 0x8005,
158         ARRAY_BUFFER = 0x8892,
159         ELEMENT_ARRAY_BUFFER = 0x8893,
160         ARRAY_BUFFER_BINDING = 0x8894,
161         ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
162         STREAM_DRAW = 0x88E0,
163         STATIC_DRAW = 0x88E4,
164         DYNAMIC_DRAW = 0x88E8,
165         BUFFER_SIZE = 0x8764,
166         BUFFER_USAGE = 0x8765,
167         CURRENT_VERTEX_ATTRIB = 0x8626,
168         FRONT = 0x0404,
169         BACK = 0x0405,
170         FRONT_AND_BACK = 0x0408,
171         TEXTURE_2D = 0x0DE1,
172         CULL_FACE = 0x0B44,
173         BLEND = 0x0BE2,
174         DITHER = 0x0BD0,
175         STENCIL_TEST = 0x0B90,
176         DEPTH_TEST = 0x0B71,
177         SCISSOR_TEST = 0x0C11,
178         POLYGON_OFFSET_FILL = 0x8037,
179         SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
180         SAMPLE_COVERAGE = 0x80A0,
181         NO_ERROR = 0,
182         INVALID_ENUM = 0x0500,
183         INVALID_VALUE = 0x0501,
184         INVALID_OPERATION = 0x0502,
185         OUT_OF_MEMORY = 0x0505,
186         CW = 0x0900,
187         CCW = 0x0901,
188         LINE_WIDTH = 0x0B21,
189         ALIASED_POINT_SIZE_RANGE = 0x846D,
190         ALIASED_LINE_WIDTH_RANGE = 0x846E,
191         CULL_FACE_MODE = 0x0B45,
192         FRONT_FACE = 0x0B46,
193         DEPTH_RANGE = 0x0B70,
194         DEPTH_WRITEMASK = 0x0B72,
195         DEPTH_CLEAR_VALUE = 0x0B73,
196         DEPTH_FUNC = 0x0B74,
197         STENCIL_CLEAR_VALUE = 0x0B91,
198         STENCIL_FUNC = 0x0B92,
199         STENCIL_FAIL = 0x0B94,
200         STENCIL_PASS_DEPTH_FAIL = 0x0B95,
201         STENCIL_PASS_DEPTH_PASS = 0x0B96,
202         STENCIL_REF = 0x0B97,
203         STENCIL_VALUE_MASK = 0x0B93,
204         STENCIL_WRITEMASK = 0x0B98,
205         STENCIL_BACK_FUNC = 0x8800,
206         STENCIL_BACK_FAIL = 0x8801,
207         STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
208         STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
209         STENCIL_BACK_REF = 0x8CA3,
210         STENCIL_BACK_VALUE_MASK = 0x8CA4,
211         STENCIL_BACK_WRITEMASK = 0x8CA5,
212         VIEWPORT = 0x0BA2,
213         SCISSOR_BOX = 0x0C10,
214         COLOR_CLEAR_VALUE = 0x0C22,
215         COLOR_WRITEMASK = 0x0C23,
216         UNPACK_ALIGNMENT = 0x0CF5,
217         PACK_ALIGNMENT = 0x0D05,
218         MAX_TEXTURE_SIZE = 0x0D33,
219         MAX_VIEWPORT_DIMS = 0x0D3A,
220         SUBPIXEL_BITS = 0x0D50,
221         RED_BITS = 0x0D52,
222         GREEN_BITS = 0x0D53,
223         BLUE_BITS = 0x0D54,
224         ALPHA_BITS = 0x0D55,
225         DEPTH_BITS = 0x0D56,
226         STENCIL_BITS = 0x0D57,
227         POLYGON_OFFSET_UNITS = 0x2A00,
228         POLYGON_OFFSET_FACTOR = 0x8038,
229         TEXTURE_BINDING_2D = 0x8069,
230         SAMPLE_BUFFERS = 0x80A8,
231         SAMPLES = 0x80A9,
232         SAMPLE_COVERAGE_VALUE = 0x80AA,
233         SAMPLE_COVERAGE_INVERT = 0x80AB,
234         NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2,
235         COMPRESSED_TEXTURE_FORMATS = 0x86A3,
236         DONT_CARE = 0x1100,
237         FASTEST = 0x1101,
238         NICEST = 0x1102,
239         GENERATE_MIPMAP_HINT = 0x8192,
240         BYTE = 0x1400,
241         UNSIGNED_BYTE = 0x1401,
242         SHORT = 0x1402,
243         UNSIGNED_SHORT = 0x1403,
244         INT = 0x1404,
245         UNSIGNED_INT = 0x1405,
246         FLOAT = 0x1406,
247         HALF_FLOAT_OES = 0x8D61,
248         FIXED = 0x140C,
249         DEPTH_COMPONENT = 0x1902,
250         ALPHA = 0x1906,
251         RGB = 0x1907,
252         RGBA = 0x1908,
253         BGRA = 0x80E1,
254         LUMINANCE = 0x1909,
255         LUMINANCE_ALPHA = 0x190A,
256         UNSIGNED_SHORT_4_4_4_4 = 0x8033,
257         UNSIGNED_SHORT_5_5_5_1 = 0x8034,
258         UNSIGNED_SHORT_5_6_5 = 0x8363,
259         FRAGMENT_SHADER = 0x8B30,
260         VERTEX_SHADER = 0x8B31,
261         MAX_VERTEX_ATTRIBS = 0x8869,
262         MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB,
263         MAX_VARYING_VECTORS = 0x8DFC,
264         MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
265         MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C,
266         MAX_TEXTURE_IMAGE_UNITS = 0x8872,
267         MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD,
268         SHADER_TYPE = 0x8B4F,
269         DELETE_STATUS = 0x8B80,
270         LINK_STATUS = 0x8B82,
271         VALIDATE_STATUS = 0x8B83,
272         ATTACHED_SHADERS = 0x8B85,
273         ACTIVE_UNIFORMS = 0x8B86,
274         ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
275         ACTIVE_ATTRIBUTES = 0x8B89,
276         ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
277         SHADING_LANGUAGE_VERSION = 0x8B8C,
278         CURRENT_PROGRAM = 0x8B8D,
279         NEVER = 0x0200,
280         LESS = 0x0201,
281         EQUAL = 0x0202,
282         LEQUAL = 0x0203,
283         GREATER = 0x0204,
284         NOTEQUAL = 0x0205,
285         GEQUAL = 0x0206,
286         ALWAYS = 0x0207,
287         KEEP = 0x1E00,
288         REPLACE = 0x1E01,
289         INCR = 0x1E02,
290         DECR = 0x1E03,
291         INVERT = 0x150A,
292         INCR_WRAP = 0x8507,
293         DECR_WRAP = 0x8508,
294         VENDOR = 0x1F00,
295         RENDERER = 0x1F01,
296         VERSION = 0x1F02,
297         EXTENSIONS = 0x1F03,
298         NEAREST = 0x2600,
299         LINEAR = 0x2601,
300         NEAREST_MIPMAP_NEAREST = 0x2700,
301         LINEAR_MIPMAP_NEAREST = 0x2701,
302         NEAREST_MIPMAP_LINEAR = 0x2702,
303         LINEAR_MIPMAP_LINEAR = 0x2703,
304         TEXTURE_MAG_FILTER = 0x2800,
305         TEXTURE_MIN_FILTER = 0x2801,
306         TEXTURE_WRAP_S = 0x2802,
307         TEXTURE_WRAP_T = 0x2803,
308         TEXTURE = 0x1702,
309         TEXTURE_CUBE_MAP = 0x8513,
310         TEXTURE_BINDING_CUBE_MAP = 0x8514,
311         TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
312         TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
313         TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
314         TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
315         TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
316         TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A,
317         MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C,
318         TEXTURE0 = 0x84C0,
319         TEXTURE1 = 0x84C1,
320         TEXTURE2 = 0x84C2,
321         TEXTURE3 = 0x84C3,
322         TEXTURE4 = 0x84C4,
323         TEXTURE5 = 0x84C5,
324         TEXTURE6 = 0x84C6,
325         TEXTURE7 = 0x84C7,
326         TEXTURE8 = 0x84C8,
327         TEXTURE9 = 0x84C9,
328         TEXTURE10 = 0x84CA,
329         TEXTURE11 = 0x84CB,
330         TEXTURE12 = 0x84CC,
331         TEXTURE13 = 0x84CD,
332         TEXTURE14 = 0x84CE,
333         TEXTURE15 = 0x84CF,
334         TEXTURE16 = 0x84D0,
335         TEXTURE17 = 0x84D1,
336         TEXTURE18 = 0x84D2,
337         TEXTURE19 = 0x84D3,
338         TEXTURE20 = 0x84D4,
339         TEXTURE21 = 0x84D5,
340         TEXTURE22 = 0x84D6,
341         TEXTURE23 = 0x84D7,
342         TEXTURE24 = 0x84D8,
343         TEXTURE25 = 0x84D9,
344         TEXTURE26 = 0x84DA,
345         TEXTURE27 = 0x84DB,
346         TEXTURE28 = 0x84DC,
347         TEXTURE29 = 0x84DD,
348         TEXTURE30 = 0x84DE,
349         TEXTURE31 = 0x84DF,
350         ACTIVE_TEXTURE = 0x84E0,
351         REPEAT = 0x2901,
352         CLAMP_TO_EDGE = 0x812F,
353         MIRRORED_REPEAT = 0x8370,
354         FLOAT_VEC2 = 0x8B50,
355         FLOAT_VEC3 = 0x8B51,
356         FLOAT_VEC4 = 0x8B52,
357         INT_VEC2 = 0x8B53,
358         INT_VEC3 = 0x8B54,
359         INT_VEC4 = 0x8B55,
360         BOOL = 0x8B56,
361         BOOL_VEC2 = 0x8B57,
362         BOOL_VEC3 = 0x8B58,
363         BOOL_VEC4 = 0x8B59,
364         FLOAT_MAT2 = 0x8B5A,
365         FLOAT_MAT3 = 0x8B5B,
366         FLOAT_MAT4 = 0x8B5C,
367         SAMPLER_2D = 0x8B5E,
368         SAMPLER_CUBE = 0x8B60,
369         VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
370         VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
371         VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
372         VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
373         VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A,
374         VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
375         VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
376         COMPILE_STATUS = 0x8B81,
377         INFO_LOG_LENGTH = 0x8B84,
378         SHADER_SOURCE_LENGTH = 0x8B88,
379         SHADER_COMPILER = 0x8DFA,
380         SHADER_BINARY_FORMATS = 0x8DF8,
381         NUM_SHADER_BINARY_FORMATS = 0x8DF9,
382         LOW_FLOAT = 0x8DF0,
383         MEDIUM_FLOAT = 0x8DF1,
384         HIGH_FLOAT = 0x8DF2,
385         LOW_INT = 0x8DF3,
386         MEDIUM_INT = 0x8DF4,
387         HIGH_INT = 0x8DF5,
388         FRAMEBUFFER = 0x8D40,
389         RENDERBUFFER = 0x8D41,
390         RGBA4 = 0x8056,
391         RGB5_A1 = 0x8057,
392         RGB565 = 0x8D62,
393         DEPTH_COMPONENT16 = 0x81A5,
394         STENCIL_INDEX = 0x1901,
395         STENCIL_INDEX8 = 0x8D48,
396         DEPTH_STENCIL = 0x84F9,
397         UNSIGNED_INT_24_8 = 0x84FA,
398         DEPTH24_STENCIL8 = 0x88F0,
399         RENDERBUFFER_WIDTH = 0x8D42,
400         RENDERBUFFER_HEIGHT = 0x8D43,
401         RENDERBUFFER_INTERNAL_FORMAT = 0x8D44,
402         RENDERBUFFER_RED_SIZE = 0x8D50,
403         RENDERBUFFER_GREEN_SIZE = 0x8D51,
404         RENDERBUFFER_BLUE_SIZE = 0x8D52,
405         RENDERBUFFER_ALPHA_SIZE = 0x8D53,
406         RENDERBUFFER_DEPTH_SIZE = 0x8D54,
407         RENDERBUFFER_STENCIL_SIZE = 0x8D55,
408         FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0,
409         FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1,
410         FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2,
411         FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3,
412         COLOR_ATTACHMENT0 = 0x8CE0,
413         DEPTH_ATTACHMENT = 0x8D00,
414         STENCIL_ATTACHMENT = 0x8D20,
415         DEPTH_STENCIL_ATTACHMENT = 0x821A,
416         NONE = 0,
417         FRAMEBUFFER_COMPLETE = 0x8CD5,
418         FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6,
419         FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7,
420         FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9,
421         FRAMEBUFFER_UNSUPPORTED = 0x8CDD,
422         FRAMEBUFFER_BINDING = 0x8CA6,
423         RENDERBUFFER_BINDING = 0x8CA7,
424         MAX_RENDERBUFFER_SIZE = 0x84E8,
425         INVALID_FRAMEBUFFER_OPERATION = 0x0506,
426
427         // WebGL-specific enums
428         UNPACK_FLIP_Y_WEBGL = 0x9240,
429         UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241,
430         CONTEXT_LOST_WEBGL = 0x9242,
431         UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243,
432         BROWSER_DEFAULT_WEBGL = 0x9244
433     };
434
435     // Context creation attributes.
436     struct Attributes {
437         Attributes()
438             : alpha(true)
439             , depth(true)
440             , stencil(false)
441             , antialias(true)
442             , premultipliedAlpha(true)
443             , preserveDrawingBuffer(false)
444             , noExtensions(false)
445             , shareResources(true)
446             , preferDiscreteGPU(false)
447         {
448         }
449
450         bool alpha;
451         bool depth;
452         bool stencil;
453         bool antialias;
454         bool premultipliedAlpha;
455         bool preserveDrawingBuffer;
456         bool noExtensions;
457         bool shareResources;
458         bool preferDiscreteGPU;
459         KURL topDocumentURL;
460     };
461
462     enum RenderStyle {
463         RenderOffscreen,
464         RenderDirectlyToHostWindow,
465         RenderToCurrentGLContext
466     };
467
468     class ContextLostCallback {
469     public:
470         virtual void onContextLost() = 0;
471         virtual ~ContextLostCallback() {}
472     };
473
474     class ErrorMessageCallback {
475     public:
476         virtual void onErrorMessage(const String& message, GC3Dint id) = 0;
477         virtual ~ErrorMessageCallback() { }
478     };
479
480     void setContextLostCallback(PassOwnPtr<ContextLostCallback>);
481     void setErrorMessageCallback(PassOwnPtr<ErrorMessageCallback>);
482
483     static PassRefPtr<GraphicsContext3D> create(Attributes, HostWindow*, RenderStyle = RenderOffscreen);
484     static PassRefPtr<GraphicsContext3D> createForCurrentGLContext();
485     ~GraphicsContext3D();
486
487 #if PLATFORM(MAC)
488     PlatformGraphicsContext3D platformGraphicsContext3D() const { return m_contextObj; }
489     Platform3DObject platformTexture() const { return m_compositorTexture; }
490     CALayer* platformLayer() const { return reinterpret_cast<CALayer*>(m_webGLLayer.get()); }
491 #else
492     PlatformGraphicsContext3D platformGraphicsContext3D();
493     Platform3DObject platformTexture() const;
494 #if USE(ACCELERATED_COMPOSITING) 
495     PlatformLayer* platformLayer() const;
496 #endif
497 #endif
498
499     bool makeContextCurrent();
500
501 #if PLATFORM(MAC) || PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(EFL) || PLATFORM(BLACKBERRY) || PLATFORM(WIN)
502     // With multisampling on, blit from multisampleFBO to regular FBO.
503     void prepareTexture();
504 #endif
505
506     // Equivalent to ::glTexImage2D(). Allows pixels==0 with no allocation.
507     void texImage2DDirect(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels);
508
509     // Helper to texImage2D with pixel==0 case: pixels are initialized to 0.
510     // Return true if no GL error is synthesized.
511     // By default, alignment is 4, the OpenGL default setting.
512     bool texImage2DResourceSafe(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint alignment = 4);
513
514     bool isGLES2Compliant() const;
515
516     //----------------------------------------------------------------------
517     // Helpers for texture uploading and pixel readback.
518     //
519
520     // Computes the components per pixel and bytes per component
521     // for the given format and type combination. Returns false if
522     // either was an invalid enum.
523     static bool computeFormatAndTypeParameters(GC3Denum format,
524                                                GC3Denum type,
525                                                unsigned int* componentsPerPixel,
526                                                unsigned int* bytesPerComponent);
527
528     // Computes the image size in bytes. If paddingInBytes is not null, padding
529     // is also calculated in return. Returns NO_ERROR if succeed, otherwise
530     // return the suggested GL error indicating the cause of the failure:
531     //   INVALID_VALUE if width/height is negative or overflow happens.
532     //   INVALID_ENUM if format/type is illegal.
533     static GC3Denum computeImageSizeInBytes(GC3Denum format,
534                                      GC3Denum type,
535                                      GC3Dsizei width,
536                                      GC3Dsizei height,
537                                      GC3Dint alignment,
538                                      unsigned int* imageSizeInBytes,
539                                      unsigned int* paddingInBytes);
540
541     // Extracts the contents of the given ImageData into the passed Vector,
542     // packing the pixel data according to the given format and type,
543     // and obeying the flipY and premultiplyAlpha flags. Returns true
544     // upon success.
545     static bool extractImageData(ImageData*,
546                           GC3Denum format,
547                           GC3Denum type,
548                           bool flipY,
549                           bool premultiplyAlpha,
550                           Vector<uint8_t>& data);
551
552     // Helper function which extracts the user-supplied texture
553     // data, applying the flipY and premultiplyAlpha parameters.
554     // If the data is not tightly packed according to the passed
555     // unpackAlignment, the output data will be tightly packed.
556     // Returns true if successful, false if any error occurred.
557     static bool extractTextureData(unsigned int width, unsigned int height,
558                             GC3Denum format, GC3Denum type,
559                             unsigned int unpackAlignment,
560                             bool flipY, bool premultiplyAlpha,
561                             const void* pixels,
562                             Vector<uint8_t>& data);
563
564
565     // Attempt to enumerate all possible native image formats to
566     // reduce the amount of temporary allocations during texture
567     // uploading. This enum must be public because it is accessed
568     // by non-member functions.
569     enum DataFormat {
570         DataFormatRGBA8 = 0,
571         DataFormatRGBA16Little,
572         DataFormatRGBA16Big,
573         DataFormatRGBA32F,
574         DataFormatRGB8,
575         DataFormatRGB16Little,
576         DataFormatRGB16Big,
577         DataFormatRGB32F,
578         DataFormatBGR8,
579         DataFormatBGRA8,
580         DataFormatBGRA16Little,
581         DataFormatBGRA16Big,
582         DataFormatARGB8,
583         DataFormatARGB16Little,
584         DataFormatARGB16Big,
585         DataFormatABGR8,
586         DataFormatRGBA5551,
587         DataFormatRGBA4444,
588         DataFormatRGB565,
589         DataFormatR8,
590         DataFormatR16Little,
591         DataFormatR16Big,
592         DataFormatR32F,
593         DataFormatRA8,
594         DataFormatRA16Little,
595         DataFormatRA16Big,
596         DataFormatRA32F,
597         DataFormatAR8,
598         DataFormatAR16Little,
599         DataFormatAR16Big,
600         DataFormatA8,
601         DataFormatA16Little,
602         DataFormatA16Big,
603         DataFormatA32F,
604         DataFormatNumFormats
605     };
606
607     // Check if the format is one of the formats from the ImageData or DOM elements.
608     // The formats from ImageData is always RGBA8.
609     // The formats from DOM elements vary with Graphics ports. It can only be RGBA8 or BGRA8 for non-CG port while a little more for CG port.
610     static ALWAYS_INLINE bool srcFormatComeFromDOMElementOrImageData(DataFormat SrcFormat)
611     {
612 #if USE(CG)
613 #if CPU(BIG_ENDIAN)
614     return SrcFormat == DataFormatRGBA8 || SrcFormat == DataFormatARGB8 || SrcFormat == DataFormatRGB8;
615 #else
616     // That LITTLE_ENDIAN case has more possible formats than BIG_ENDIAN case is because some decoded image data is actually big endian
617     // even on little endian architectures.
618     return SrcFormat == DataFormatBGRA8 || SrcFormat == DataFormatABGR8 || SrcFormat == DataFormatBGR8
619         || SrcFormat == DataFormatRGBA8 || SrcFormat == DataFormatARGB8 || SrcFormat == DataFormatRGB8;
620 #endif
621 #else
622     return SrcFormat == DataFormatBGRA8 || SrcFormat == DataFormatRGBA8;
623 #endif
624     }
625
626     //----------------------------------------------------------------------
627     // Entry points for WebGL.
628     //
629
630     void activeTexture(GC3Denum texture);
631     void attachShader(Platform3DObject program, Platform3DObject shader);
632     void bindAttribLocation(Platform3DObject, GC3Duint index, const String& name);
633     void bindBuffer(GC3Denum target, Platform3DObject);
634     void bindFramebuffer(GC3Denum target, Platform3DObject);
635     void bindRenderbuffer(GC3Denum target, Platform3DObject);
636     void bindTexture(GC3Denum target, Platform3DObject);
637     void blendColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha);
638     void blendEquation(GC3Denum mode);
639     void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
640     void blendFunc(GC3Denum sfactor, GC3Denum dfactor);
641     void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);
642
643     void bufferData(GC3Denum target, GC3Dsizeiptr size, GC3Denum usage);
644     void bufferData(GC3Denum target, GC3Dsizeiptr size, const void* data, GC3Denum usage);
645     void bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr size, const void* data);
646
647     GC3Denum checkFramebufferStatus(GC3Denum target);
648     void clear(GC3Dbitfield mask);
649     void clearColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha);
650     void clearDepth(GC3Dclampf depth);
651     void clearStencil(GC3Dint s);
652     void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
653     void compileShader(Platform3DObject);
654
655     void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Dsizei imageSize, const void* data);
656     void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Dsizei imageSize, const void* data);
657     void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);
658     void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
659     void cullFace(GC3Denum mode);
660     void depthFunc(GC3Denum func);
661     void depthMask(GC3Dboolean flag);
662     void depthRange(GC3Dclampf zNear, GC3Dclampf zFar);
663     void detachShader(Platform3DObject, Platform3DObject);
664     void disable(GC3Denum cap);
665     void disableVertexAttribArray(GC3Duint index);
666     void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count);
667     void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
668
669     void enable(GC3Denum cap);
670     void enableVertexAttribArray(GC3Duint index);
671     void finish();
672     void flush();
673     void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, Platform3DObject);
674     void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, Platform3DObject, GC3Dint level);
675     void frontFace(GC3Denum mode);
676     void generateMipmap(GC3Denum target);
677
678     bool getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo&);
679     bool getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo&);
680     void getAttachedShaders(Platform3DObject program, GC3Dsizei maxCount, GC3Dsizei* count, Platform3DObject* shaders);
681     GC3Dint getAttribLocation(Platform3DObject, const String& name);
682     void getBooleanv(GC3Denum pname, GC3Dboolean* value);
683     void getBufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value);
684     Attributes getContextAttributes();
685     GC3Denum getError();
686     void getFloatv(GC3Denum pname, GC3Dfloat* value);
687     void getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum pname, GC3Dint* value);
688     void getIntegerv(GC3Denum pname, GC3Dint* value);
689     void getProgramiv(Platform3DObject program, GC3Denum pname, GC3Dint* value);
690     String getProgramInfoLog(Platform3DObject);
691     void getRenderbufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value);
692     void getShaderiv(Platform3DObject, GC3Denum pname, GC3Dint* value);
693     String getShaderInfoLog(Platform3DObject);
694     void getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, GC3Dint* range, GC3Dint* precision);
695     String getShaderSource(Platform3DObject);
696     String getString(GC3Denum name);
697     void getTexParameterfv(GC3Denum target, GC3Denum pname, GC3Dfloat* value);
698     void getTexParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value);
699     void getUniformfv(Platform3DObject program, GC3Dint location, GC3Dfloat* value);
700     void getUniformiv(Platform3DObject program, GC3Dint location, GC3Dint* value);
701     GC3Dint getUniformLocation(Platform3DObject, const String& name);
702     void getVertexAttribfv(GC3Duint index, GC3Denum pname, GC3Dfloat* value);
703     void getVertexAttribiv(GC3Duint index, GC3Denum pname, GC3Dint* value);
704     GC3Dsizeiptr getVertexAttribOffset(GC3Duint index, GC3Denum pname);
705
706     void hint(GC3Denum target, GC3Denum mode);
707     GC3Dboolean isBuffer(Platform3DObject);
708     GC3Dboolean isEnabled(GC3Denum cap);
709     GC3Dboolean isFramebuffer(Platform3DObject);
710     GC3Dboolean isProgram(Platform3DObject);
711     GC3Dboolean isRenderbuffer(Platform3DObject);
712     GC3Dboolean isShader(Platform3DObject);
713     GC3Dboolean isTexture(Platform3DObject);
714     void lineWidth(GC3Dfloat);
715     void linkProgram(Platform3DObject);
716     void pixelStorei(GC3Denum pname, GC3Dint param);
717     void polygonOffset(GC3Dfloat factor, GC3Dfloat units);
718
719     void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data);
720
721     void releaseShaderCompiler();
722
723     void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
724     void sampleCoverage(GC3Dclampf value, GC3Dboolean invert);
725     void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
726     void shaderSource(Platform3DObject, const String& string);
727     void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);
728     void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);
729     void stencilMask(GC3Duint mask);
730     void stencilMaskSeparate(GC3Denum face, GC3Duint mask);
731     void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
732     void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
733
734     bool texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels);
735     void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
736     void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
737     void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels);
738
739     void uniform1f(GC3Dint location, GC3Dfloat x);
740     void uniform1fv(GC3Dint location, GC3Dsizei, GC3Dfloat* v);
741     void uniform1i(GC3Dint location, GC3Dint x);
742     void uniform1iv(GC3Dint location, GC3Dsizei, GC3Dint* v);
743     void uniform2f(GC3Dint location, GC3Dfloat x, GC3Dfloat y);
744     void uniform2fv(GC3Dint location, GC3Dsizei, GC3Dfloat* v);
745     void uniform2i(GC3Dint location, GC3Dint x, GC3Dint y);
746     void uniform2iv(GC3Dint location, GC3Dsizei, GC3Dint* v);
747     void uniform3f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
748     void uniform3fv(GC3Dint location, GC3Dsizei, GC3Dfloat* v);
749     void uniform3i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z);
750     void uniform3iv(GC3Dint location, GC3Dsizei, GC3Dint* v);
751     void uniform4f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
752     void uniform4fv(GC3Dint location, GC3Dsizei, GC3Dfloat* v);
753     void uniform4i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w);
754     void uniform4iv(GC3Dint location, GC3Dsizei, GC3Dint* v);
755     void uniformMatrix2fv(GC3Dint location, GC3Dsizei, GC3Dboolean transpose, GC3Dfloat* value);
756     void uniformMatrix3fv(GC3Dint location, GC3Dsizei, GC3Dboolean transpose, GC3Dfloat* value);
757     void uniformMatrix4fv(GC3Dint location, GC3Dsizei, GC3Dboolean transpose, GC3Dfloat* value);
758
759     void useProgram(Platform3DObject);
760     void validateProgram(Platform3DObject);
761
762     void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
763     void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values);
764     void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
765     void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values);
766     void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
767     void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values);
768     void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
769     void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values);
770     void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
771                              GC3Dsizei stride, GC3Dintptr offset);
772
773     void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
774
775     void reshape(int width, int height);
776
777 #if PLATFORM(GTK) || PLATFORM(EFL) || USE(CAIRO)
778     void paintToCanvas(const unsigned char* imagePixels, int imageWidth, int imageHeight,
779                        int canvasWidth, int canvasHeight, PlatformContextCairo* context);
780 #elif PLATFORM(QT)
781     void paintToCanvas(const unsigned char* imagePixels, int imageWidth, int imageHeight,
782                        int canvasWidth, int canvasHeight, QPainter* context);
783 #elif PLATFORM(BLACKBERRY) || USE(CG)
784     void paintToCanvas(const unsigned char* imagePixels, int imageWidth, int imageHeight,
785                        int canvasWidth, int canvasHeight, GraphicsContext*);
786 #endif
787
788     void markContextChanged();
789     void markLayerComposited();
790     bool layerComposited() const;
791
792     void paintRenderingResultsToCanvas(ImageBuffer*, DrawingBuffer*);
793     PassRefPtr<ImageData> paintRenderingResultsToImageData(DrawingBuffer*);
794     bool paintCompositedResultsToCanvas(ImageBuffer*);
795
796 #if PLATFORM(BLACKBERRY)
797     bool paintsIntoCanvasBuffer() const;
798 #endif
799
800     // Support for buffer creation and deletion
801     Platform3DObject createBuffer();
802     Platform3DObject createFramebuffer();
803     Platform3DObject createProgram();
804     Platform3DObject createRenderbuffer();
805     Platform3DObject createShader(GC3Denum);
806     Platform3DObject createTexture();
807
808     void deleteBuffer(Platform3DObject);
809     void deleteFramebuffer(Platform3DObject);
810     void deleteProgram(Platform3DObject);
811     void deleteRenderbuffer(Platform3DObject);
812     void deleteShader(Platform3DObject);
813     void deleteTexture(Platform3DObject);
814
815     // Synthesizes an OpenGL error which will be returned from a
816     // later call to getError. This is used to emulate OpenGL ES
817     // 2.0 behavior on the desktop and to enforce additional error
818     // checking mandated by WebGL.
819     //
820     // Per the behavior of glGetError, this stores at most one
821     // instance of any given error, and returns them from calls to
822     // getError in the order they were added.
823     void synthesizeGLError(GC3Denum error);
824
825     // Support for extensions. Returns a non-null object, though not
826     // all methods it contains may necessarily be supported on the
827     // current hardware. Must call Extensions3D::supports() to
828     // determine this.
829     Extensions3D* getExtensions();
830
831     IntSize getInternalFramebufferSize() const;
832
833     static unsigned getClearBitsByAttachmentType(GC3Denum);
834     static unsigned getClearBitsByFormat(GC3Denum);
835
836     enum ChannelBits {
837         ChannelRed = 1,
838         ChannelGreen = 2,
839         ChannelBlue = 4,
840         ChannelAlpha = 8,
841         ChannelDepth = 16,
842         ChannelStencil = 32,
843         ChannelRGB = ChannelRed | ChannelGreen | ChannelBlue,
844         ChannelRGBA = ChannelRGB | ChannelAlpha,
845     };
846
847     static unsigned getChannelBitsByFormat(GC3Denum);
848
849     // Possible alpha operations that may need to occur during
850     // pixel packing. FIXME: kAlphaDoUnmultiply is lossy and must
851     // be removed.
852     enum AlphaOp {
853         AlphaDoNothing = 0,
854         AlphaDoPremultiply = 1,
855         AlphaDoUnmultiply = 2
856     };
857
858     enum ImageHtmlDomSource {
859         HtmlDomImage = 0,
860         HtmlDomCanvas = 1,
861         HtmlDomVideo = 2,
862         HtmlDomNone = 3
863     };
864
865     // Packs the contents of the given Image which is passed in |pixels| into the passed Vector
866     // according to the given format and type, and obeying the flipY and AlphaOp flags.
867     // Returns true upon success.
868     static bool packImageData(Image*, const void* pixels, GC3Denum format, GC3Denum type, bool flipY, AlphaOp, DataFormat sourceFormat, unsigned width, unsigned height, unsigned sourceUnpackAlignment, Vector<uint8_t>& data);
869
870     class ImageExtractor {
871     public:
872         ImageExtractor(Image*, ImageHtmlDomSource, bool premultiplyAlpha, bool ignoreGammaAndColorProfile);
873
874         // Each platform must provide an implementation of this method to deallocate or release resources
875         // associated with the image if needed.
876         ~ImageExtractor();
877
878         bool extractSucceeded() { return m_extractSucceeded; }
879         const void* imagePixelData() { return m_imagePixelData; }
880         unsigned imageWidth() { return m_imageWidth; }
881         unsigned imageHeight() { return m_imageHeight; }
882         DataFormat imageSourceFormat() { return m_imageSourceFormat; }
883         AlphaOp imageAlphaOp() { return m_alphaOp; }
884         unsigned imageSourceUnpackAlignment() { return m_imageSourceUnpackAlignment; }
885         ImageHtmlDomSource imageHtmlDomSource() { return m_imageHtmlDomSource; }
886     private:
887         // Each platform must provide an implementation of this method.
888         // Extracts the image and keeps track of its status, such as width, height, Source Alignment, format and AlphaOp etc,
889         // needs to lock the resources or relevant data if needed and returns true upon success
890         bool extractImage(bool premultiplyAlpha, bool ignoreGammaAndColorProfile);
891
892 #if USE(CAIRO)
893         ImageSource* m_decoder;
894         RefPtr<cairo_surface_t> m_imageSurface;
895 #elif USE(CG)
896         CGImageRef m_cgImage;
897         RetainPtr<CGImageRef> m_decodedImage;
898         RetainPtr<CFDataRef> m_pixelData;
899         OwnArrayPtr<uint8_t> m_formalizedRGBA8Data;
900 #elif PLATFORM(QT)
901         QImage m_qtImage;
902 #elif PLATFORM(BLACKBERRY)
903         Vector<unsigned> m_imageData;
904 #endif
905         Image* m_image;
906         ImageHtmlDomSource m_imageHtmlDomSource;
907         bool m_extractSucceeded;
908         const void* m_imagePixelData;
909         unsigned m_imageWidth;
910         unsigned m_imageHeight;
911         DataFormat m_imageSourceFormat;
912         AlphaOp m_alphaOp;
913         unsigned m_imageSourceUnpackAlignment;
914     };
915
916 private:
917     GraphicsContext3D(Attributes, HostWindow*, RenderStyle = RenderOffscreen);
918
919     // Helper for packImageData/extractImageData/extractTextureData which implement packing of pixel
920     // data into the specified OpenGL destination format and type.
921     // A sourceUnpackAlignment of zero indicates that the source
922     // data is tightly packed. Non-zero values may take a slow path.
923     // Destination data will have no gaps between rows.
924     static bool packPixels(const uint8_t* sourceData, DataFormat sourceDataFormat, unsigned width, unsigned height, unsigned sourceUnpackAlignment, unsigned destinationFormat, unsigned destinationType, AlphaOp, void* destinationData, bool flipY);
925
926 #if PLATFORM(MAC) || PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(EFL) || PLATFORM(BLACKBERRY) || PLATFORM(WIN)
927     // Take into account the user's requested context creation attributes,
928     // in particular stencil and antialias, and determine which could or
929     // could not be honored based on the capabilities of the OpenGL
930     // implementation.
931     void validateDepthStencil(const char* packedDepthStencilExtension);
932     void validateAttributes();
933
934     // Read rendering results into a pixel array with the same format as the
935     // backbuffer.
936     void readRenderingResults(unsigned char* pixels, int pixelsSize);
937     void readPixelsAndConvertToBGRAIfNecessary(int x, int y, int width, int height, unsigned char* pixels);
938 #endif
939
940 #if PLATFORM(BLACKBERRY)
941     void logFrameBufferStatus(int line);
942     void readPixelsIMG(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data);
943 #endif
944
945     bool reshapeFBOs(const IntSize&);
946     void resolveMultisamplingIfNecessary(const IntRect& = IntRect());
947 #if (PLATFORM(QT) || PLATFORM(EFL)) && USE(GRAPHICS_SURFACE)
948     void createGraphicsSurfaces(const IntSize&);
949 #endif
950
951     int m_currentWidth, m_currentHeight;
952     bool isResourceSafe();
953
954 #if PLATFORM(MAC)
955     CGLContextObj m_contextObj;
956     RetainPtr<WebGLLayer> m_webGLLayer;
957 #elif PLATFORM(BLACKBERRY)
958 #if USE(ACCELERATED_COMPOSITING)
959     RefPtr<PlatformLayer> m_compositingLayer;
960 #endif
961     void* m_context;
962 #endif
963
964 #if PLATFORM(MAC) || PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(EFL) || PLATFORM(BLACKBERRY) || PLATFORM(WIN)
965     struct SymbolInfo {
966         SymbolInfo()
967             : type(0)
968             , size(0)
969         {
970         }
971
972         SymbolInfo(GC3Denum type, int size, const String& mappedName)
973             : type(type)
974             , size(size)
975             , mappedName(mappedName)
976         {
977         }
978
979         bool operator==(SymbolInfo& other) const
980         {
981             return type == other.type && size == other.size && mappedName == other.mappedName;
982         }
983
984         GC3Denum type;
985         int size;
986         String mappedName;
987     };
988
989     typedef HashMap<String, SymbolInfo> ShaderSymbolMap;
990
991     struct ShaderSourceEntry {
992         GC3Denum type;
993         String source;
994         String translatedSource;
995         String log;
996         bool isValid;
997         ShaderSymbolMap attributeMap;
998         ShaderSymbolMap uniformMap;
999         ShaderSourceEntry()
1000             : type(VERTEX_SHADER)
1001             , isValid(false)
1002         {
1003         }
1004         
1005         ShaderSymbolMap& symbolMap(enum ANGLEShaderSymbolType symbolType)
1006         {
1007             ASSERT(symbolType == SHADER_SYMBOL_TYPE_ATTRIBUTE || symbolType == SHADER_SYMBOL_TYPE_UNIFORM);
1008             if (symbolType == SHADER_SYMBOL_TYPE_ATTRIBUTE)
1009                 return attributeMap;
1010             return uniformMap;
1011         }
1012     };
1013
1014     typedef HashMap<Platform3DObject, ShaderSourceEntry> ShaderSourceMap;
1015     ShaderSourceMap m_shaderSourceMap;
1016
1017     String mappedSymbolName(Platform3DObject program, ANGLEShaderSymbolType, const String& name);
1018     String originalSymbolName(Platform3DObject program, ANGLEShaderSymbolType, const String& name);
1019
1020     ANGLEWebKitBridge m_compiler;
1021 #endif
1022
1023 #if PLATFORM(BLACKBERRY) || (PLATFORM(QT) && defined(QT_OPENGL_ES_2)) || ((PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2))
1024     friend class Extensions3DOpenGLES;
1025     OwnPtr<Extensions3DOpenGLES> m_extensions;
1026 #else
1027     friend class Extensions3DOpenGL;
1028     OwnPtr<Extensions3DOpenGL> m_extensions;
1029 #endif
1030     friend class Extensions3DOpenGLCommon;
1031
1032     Attributes m_attrs;
1033     RenderStyle m_renderStyle;
1034     Vector<Vector<float> > m_vertexArray;
1035
1036     GC3Duint m_texture;
1037 #if !PLATFORM(BLACKBERRY)
1038     GC3Duint m_compositorTexture;
1039 #endif
1040     GC3Duint m_fbo;
1041
1042 #if !PLATFORM(BLACKBERRY)
1043     GC3Duint m_depthBuffer;
1044     GC3Duint m_stencilBuffer;
1045 #endif
1046     GC3Duint m_depthStencilBuffer;
1047
1048     bool m_layerComposited;
1049     GC3Duint m_internalColorFormat;
1050
1051     struct GraphicsContext3DState {
1052         GraphicsContext3DState()
1053             : boundFBO(0)
1054             , activeTexture(GraphicsContext3D::TEXTURE0)
1055             , boundTexture0(0)
1056         { }
1057
1058         GC3Duint boundFBO;
1059         GC3Denum activeTexture;
1060         GC3Duint boundTexture0;
1061     };
1062
1063     GraphicsContext3DState m_state;
1064
1065     // For multisampling
1066     GC3Duint m_multisampleFBO;
1067     GC3Duint m_multisampleDepthStencilBuffer;
1068     GC3Duint m_multisampleColorBuffer;
1069
1070     // Errors raised by synthesizeGLError().
1071     ListHashSet<GC3Denum> m_syntheticErrors;
1072
1073 #if PLATFORM(BLACKBERRY)
1074     bool m_isImaginationHardware;
1075 #endif
1076
1077 #if !PLATFORM(BLACKBERRY)
1078     friend class GraphicsContext3DPrivate;
1079     OwnPtr<GraphicsContext3DPrivate> m_private;
1080 #endif
1081 };
1082
1083 } // namespace WebCore
1084
1085 #endif // GraphicsContext3D_h