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)
51#include "ANGLEWebKitBridge.h"
52#endif
53
54#if PLATFORM(MAC)
55#include <wtf/RetainPtr.h>
56OBJC_CLASS CALayer;
57OBJC_CLASS WebGLLayer;
58#elif PLATFORM(QT)
59QT_BEGIN_NAMESPACE
60class QPainter;
61class QRect;
62class QGLWidget;
63class QGLContext;
64class QOpenGLContext;
65class QSurface;
66QT_END_NAMESPACE
67#elif PLATFORM(GTK) || PLATFORM(EFL)
68typedef unsigned int GLuint;
69#endif
70
71#if PLATFORM(MAC)
72typedef struct _CGLContextObject *CGLContextObj;
73
74typedef CGLContextObj PlatformGraphicsContext3D;
75#elif PLATFORM(QT)
76typedef QOpenGLContext* PlatformGraphicsContext3D;
77typedef QSurface* PlatformGraphicsSurface3D;
78#else
79typedef void* PlatformGraphicsContext3D;
80typedef void* PlatformGraphicsSurface3D;
81#endif
82
83// These are currently the same among all implementations.
84const PlatformGraphicsContext3D NullPlatformGraphicsContext3D = 0;
85const Platform3DObject NullPlatform3DObject = 0;
86
87namespace WebCore {
88class DrawingBuffer;
89class Extensions3D;
90#if USE(OPENGL_ES_2)
91class Extensions3DOpenGLES;
92#else
93class Extensions3DOpenGL;
94#endif
95#if PLATFORM(QT)
96class Extensions3DQt;
97#endif
98class HostWindow;
99class Image;
100class ImageBuffer;
101class ImageSource;
102class ImageData;
103class IntRect;
104class IntSize;
105#if USE(CAIRO)
106class PlatformContextCairo;
107#elif PLATFORM(BLACKBERRY)
108class GraphicsContext;
109#endif
110
111struct ActiveInfo {
112    String name;
113    GC3Denum type;
114    GC3Dint size;
115};
116
117class GraphicsContext3DPrivate;
118
119class GraphicsContext3D : public RefCounted<GraphicsContext3D> {
120public:
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)
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)
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
916private:
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)
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)
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(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
1086