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