1 /* 2 * Copyright (C) 2010 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 #include "config.h" 27 28 #if ENABLE(WEBGL) 29 30 #include "GraphicsContext3D.h" 31 32 #include "ArrayBuffer.h" 33 #include "ArrayBufferView.h" 34 #include "WebGLObject.h" 35 #include "CanvasRenderingContext.h" 36 #include "Extensions3DOpenGL.h" 37 #include "Float32Array.h" 38 #include "GraphicsContext.h" 39 #include "HTMLCanvasElement.h" 40 #include "ImageBuffer.h" 41 #include "ImageData.h" 42 #include "Int32Array.h" 43 #include "NotImplemented.h" 44 #include "Uint8Array.h" 45 #include <cstring> 46 #include <wtf/UnusedParam.h> 47 #include <wtf/text/CString.h> 48 49 #if PLATFORM(MAC) 50 #include <OpenGL/gl.h> 51 #elif PLATFORM(GTK) 52 #include "OpenGLShims.h" 53 #endif 54 55 namespace WebCore { 56 57 void GraphicsContext3D::validateAttributes() 58 { 59 Extensions3D* extensions = getExtensions(); 60 if (m_attrs.stencil) { 61 if (extensions->supports("GL_EXT_packed_depth_stencil")) { 62 extensions->ensureEnabled("GL_EXT_packed_depth_stencil"); 63 // Force depth if stencil is true. 64 m_attrs.depth = true; 65 } else 66 m_attrs.stencil = false; 67 } 68 if (m_attrs.antialias) { 69 bool isValidVendor = true; 70 // Currently in Mac we only turn on antialias if vendor is NVIDIA. 71 const char* vendor = reinterpret_cast<const char*>(::glGetString(GL_VENDOR)); 72 if (!std::strstr(vendor, "NVIDIA")) 73 isValidVendor = false; 74 if (!isValidVendor || !extensions->supports("GL_ANGLE_framebuffer_multisample")) 75 m_attrs.antialias = false; 76 else 77 extensions->ensureEnabled("GL_ANGLE_framebuffer_multisample"); 78 } 79 } 80 81 void GraphicsContext3D::readRenderingResults(unsigned char *pixels, int pixelsSize) 82 { 83 if (pixelsSize < m_currentWidth * m_currentHeight * 4) 84 return; 85 86 makeContextCurrent(); 87 88 bool mustRestoreFBO = false; 89 if (m_attrs.antialias) { 90 ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO); 91 ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo); 92 ::glBlitFramebufferEXT(0, 0, m_currentWidth, m_currentHeight, 0, 0, m_currentWidth, m_currentHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR); 93 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 94 mustRestoreFBO = true; 95 } else { 96 if (m_boundFBO != m_fbo) { 97 mustRestoreFBO = true; 98 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 99 } 100 } 101 102 GLint packAlignment = 4; 103 bool mustRestorePackAlignment = false; 104 ::glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment); 105 if (packAlignment > 4) { 106 ::glPixelStorei(GL_PACK_ALIGNMENT, 4); 107 mustRestorePackAlignment = true; 108 } 109 110 ::glReadPixels(0, 0, m_currentWidth, m_currentHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels); 111 112 if (mustRestorePackAlignment) 113 ::glPixelStorei(GL_PACK_ALIGNMENT, packAlignment); 114 115 if (mustRestoreFBO) 116 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO); 117 } 118 119 void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context) 120 { 121 HTMLCanvasElement* canvas = context->canvas(); 122 ImageBuffer* imageBuffer = canvas->buffer(); 123 124 int rowBytes = m_currentWidth * 4; 125 int totalBytes = rowBytes * m_currentHeight; 126 127 OwnArrayPtr<unsigned char> pixels = adoptArrayPtr(new unsigned char[totalBytes]); 128 if (!pixels) 129 return; 130 131 readRenderingResults(pixels.get(), totalBytes); 132 133 if (!m_attrs.premultipliedAlpha) { 134 for (int i = 0; i < totalBytes; i += 4) { 135 // Premultiply alpha 136 pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255); 137 pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255); 138 pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255); 139 } 140 } 141 142 paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight, 143 canvas->width(), canvas->height(), imageBuffer->context()->platformContext()); 144 } 145 146 PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData() 147 { 148 // Reading premultiplied alpha would involve unpremultiplying, which is 149 // lossy 150 if (m_attrs.premultipliedAlpha) 151 return 0; 152 153 RefPtr<ImageData> imageData = ImageData::create(IntSize(m_currentWidth, m_currentHeight)); 154 unsigned char* pixels = imageData->data()->data()->data(); 155 int totalBytes = 4 * m_currentWidth * m_currentHeight; 156 157 readRenderingResults(pixels, totalBytes); 158 159 // Convert to RGBA 160 for (int i = 0; i < totalBytes; i += 4) 161 std::swap(pixels[i], pixels[i + 2]); 162 163 return imageData.release(); 164 } 165 166 void GraphicsContext3D::reshape(int width, int height) 167 { 168 if (!platformGraphicsContext3D()) 169 return; 170 171 if (width == m_currentWidth && height == m_currentHeight) 172 return; 173 174 m_currentWidth = width; 175 m_currentHeight = height; 176 177 makeContextCurrent(); 178 validateAttributes(); 179 180 GLuint colorFormat, internalDepthStencilFormat = 0; 181 if (m_attrs.alpha) { 182 m_internalColorFormat = GL_RGBA8; 183 colorFormat = GL_RGBA; 184 } else { 185 m_internalColorFormat = GL_RGB8; 186 colorFormat = GL_RGB; 187 } 188 if (m_attrs.stencil || m_attrs.depth) { 189 // We don't allow the logic where stencil is required and depth is not. 190 // See GraphicsContext3D::validateAttributes. 191 192 Extensions3D* extensions = getExtensions(); 193 // Use a 24 bit depth buffer where we know we have it 194 if (extensions->supports("GL_EXT_packed_depth_stencil")) 195 internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT; 196 else 197 internalDepthStencilFormat = GL_DEPTH_COMPONENT; 198 } 199 200 bool mustRestoreFBO = false; 201 202 // resize multisample FBO 203 if (m_attrs.antialias) { 204 GLint maxSampleCount; 205 ::glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount); 206 GLint sampleCount = std::min(8, maxSampleCount); 207 if (sampleCount > maxSampleCount) 208 sampleCount = maxSampleCount; 209 if (m_boundFBO != m_multisampleFBO) { 210 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO); 211 mustRestoreFBO = true; 212 } 213 ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer); 214 ::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, m_internalColorFormat, width, height); 215 ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer); 216 if (m_attrs.stencil || m_attrs.depth) { 217 ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer); 218 ::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height); 219 if (m_attrs.stencil) 220 ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer); 221 if (m_attrs.depth) 222 ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer); 223 } 224 ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); 225 if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { 226 // FIXME: cleanup. 227 notImplemented(); 228 } 229 } 230 231 // resize regular FBO 232 if (m_boundFBO != m_fbo) { 233 mustRestoreFBO = true; 234 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 235 } 236 ::glBindTexture(GL_TEXTURE_2D, m_texture); 237 ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0); 238 ::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0); 239 ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture); 240 ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0); 241 ::glBindTexture(GL_TEXTURE_2D, 0); 242 if (!m_attrs.antialias && (m_attrs.stencil || m_attrs.depth)) { 243 ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer); 244 ::glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height); 245 if (m_attrs.stencil) 246 ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer); 247 if (m_attrs.depth) 248 ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer); 249 ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); 250 } 251 if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { 252 // FIXME: cleanup 253 notImplemented(); 254 } 255 256 if (m_attrs.antialias) { 257 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO); 258 if (m_boundFBO == m_multisampleFBO) 259 mustRestoreFBO = false; 260 } 261 262 // Initialize renderbuffers to 0. 263 GLfloat clearColor[] = {0, 0, 0, 0}, clearDepth = 0; 264 GLint clearStencil = 0; 265 GLboolean colorMask[] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE}, depthMask = GL_TRUE; 266 GLuint stencilMask = 0xffffffff; 267 GLboolean isScissorEnabled = GL_FALSE; 268 GLboolean isDitherEnabled = GL_FALSE; 269 GLbitfield clearMask = GL_COLOR_BUFFER_BIT; 270 ::glGetFloatv(GL_COLOR_CLEAR_VALUE, clearColor); 271 ::glClearColor(0, 0, 0, 0); 272 ::glGetBooleanv(GL_COLOR_WRITEMASK, colorMask); 273 ::glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 274 if (m_attrs.depth) { 275 ::glGetFloatv(GL_DEPTH_CLEAR_VALUE, &clearDepth); 276 ::glClearDepth(1); 277 ::glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask); 278 ::glDepthMask(GL_TRUE); 279 clearMask |= GL_DEPTH_BUFFER_BIT; 280 } 281 if (m_attrs.stencil) { 282 ::glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &clearStencil); 283 ::glClearStencil(0); 284 ::glGetIntegerv(GL_STENCIL_WRITEMASK, reinterpret_cast<GLint*>(&stencilMask)); 285 ::glStencilMaskSeparate(GL_FRONT, 0xffffffff); 286 clearMask |= GL_STENCIL_BUFFER_BIT; 287 } 288 isScissorEnabled = ::glIsEnabled(GL_SCISSOR_TEST); 289 ::glDisable(GL_SCISSOR_TEST); 290 isDitherEnabled = ::glIsEnabled(GL_DITHER); 291 ::glDisable(GL_DITHER); 292 293 ::glClear(clearMask); 294 295 ::glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]); 296 ::glColorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]); 297 if (m_attrs.depth) { 298 ::glClearDepth(clearDepth); 299 ::glDepthMask(depthMask); 300 } 301 if (m_attrs.stencil) { 302 ::glClearStencil(clearStencil); 303 ::glStencilMaskSeparate(GL_FRONT, stencilMask); 304 } 305 if (isScissorEnabled) 306 ::glEnable(GL_SCISSOR_TEST); 307 else 308 ::glDisable(GL_SCISSOR_TEST); 309 if (isDitherEnabled) 310 ::glEnable(GL_DITHER); 311 else 312 ::glDisable(GL_DITHER); 313 314 if (mustRestoreFBO) 315 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO); 316 317 ::glFlush(); 318 } 319 320 IntSize GraphicsContext3D::getInternalFramebufferSize() 321 { 322 return IntSize(m_currentWidth, m_currentHeight); 323 } 324 325 void GraphicsContext3D::prepareTexture() 326 { 327 if (m_layerComposited) 328 return; 329 makeContextCurrent(); 330 if (m_attrs.antialias) { 331 ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO); 332 ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo); 333 ::glBlitFramebufferEXT(0, 0, m_currentWidth, m_currentHeight, 0, 0, m_currentWidth, m_currentHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR); 334 } 335 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 336 ::glActiveTexture(0); 337 ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture); 338 ::glCopyTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, 0, 0, m_currentWidth, m_currentHeight, 0); 339 ::glBindTexture(GL_TEXTURE_2D, m_boundTexture0); 340 ::glActiveTexture(m_activeTexture); 341 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO); 342 ::glFinish(); 343 m_layerComposited = true; 344 } 345 346 void GraphicsContext3D::activeTexture(GC3Denum texture) 347 { 348 makeContextCurrent(); 349 m_activeTexture = texture; 350 ::glActiveTexture(texture); 351 } 352 353 void GraphicsContext3D::attachShader(Platform3DObject program, Platform3DObject shader) 354 { 355 ASSERT(program); 356 ASSERT(shader); 357 makeContextCurrent(); 358 ::glAttachShader(program, shader); 359 } 360 361 void GraphicsContext3D::bindAttribLocation(Platform3DObject program, GC3Duint index, const String& name) 362 { 363 ASSERT(program); 364 makeContextCurrent(); 365 ::glBindAttribLocation(program, index, name.utf8().data()); 366 } 367 368 void GraphicsContext3D::bindBuffer(GC3Denum target, Platform3DObject buffer) 369 { 370 makeContextCurrent(); 371 ::glBindBuffer(target, buffer); 372 } 373 374 375 void GraphicsContext3D::bindFramebuffer(GC3Denum target, Platform3DObject buffer) 376 { 377 makeContextCurrent(); 378 GLuint fbo; 379 if (buffer) 380 fbo = buffer; 381 else 382 fbo = (m_attrs.antialias ? m_multisampleFBO : m_fbo); 383 if (fbo != m_boundFBO) { 384 ::glBindFramebufferEXT(target, fbo); 385 m_boundFBO = fbo; 386 } 387 } 388 389 void GraphicsContext3D::bindRenderbuffer(GC3Denum target, Platform3DObject renderbuffer) 390 { 391 makeContextCurrent(); 392 ::glBindRenderbufferEXT(target, renderbuffer); 393 } 394 395 396 void GraphicsContext3D::bindTexture(GC3Denum target, Platform3DObject texture) 397 { 398 makeContextCurrent(); 399 if (m_activeTexture && target == GL_TEXTURE_2D) 400 m_boundTexture0 = texture; 401 ::glBindTexture(target, texture); 402 } 403 404 void GraphicsContext3D::blendColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha) 405 { 406 makeContextCurrent(); 407 ::glBlendColor(red, green, blue, alpha); 408 } 409 410 void GraphicsContext3D::blendEquation(GC3Denum mode) 411 { 412 makeContextCurrent(); 413 ::glBlendEquation(mode); 414 } 415 416 void GraphicsContext3D::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha) 417 { 418 makeContextCurrent(); 419 ::glBlendEquationSeparate(modeRGB, modeAlpha); 420 } 421 422 423 void GraphicsContext3D::blendFunc(GC3Denum sfactor, GC3Denum dfactor) 424 { 425 makeContextCurrent(); 426 ::glBlendFunc(sfactor, dfactor); 427 } 428 429 void GraphicsContext3D::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha) 430 { 431 makeContextCurrent(); 432 ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); 433 } 434 435 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, GC3Denum usage) 436 { 437 makeContextCurrent(); 438 ::glBufferData(target, size, 0, usage); 439 } 440 441 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, const void* data, GC3Denum usage) 442 { 443 makeContextCurrent(); 444 ::glBufferData(target, size, data, usage); 445 } 446 447 void GraphicsContext3D::bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr size, const void* data) 448 { 449 makeContextCurrent(); 450 ::glBufferSubData(target, offset, size, data); 451 } 452 453 GC3Denum GraphicsContext3D::checkFramebufferStatus(GC3Denum target) 454 { 455 makeContextCurrent(); 456 return ::glCheckFramebufferStatusEXT(target); 457 } 458 459 void GraphicsContext3D::clearColor(GC3Dclampf r, GC3Dclampf g, GC3Dclampf b, GC3Dclampf a) 460 { 461 makeContextCurrent(); 462 ::glClearColor(r, g, b, a); 463 } 464 465 void GraphicsContext3D::clear(GC3Dbitfield mask) 466 { 467 makeContextCurrent(); 468 ::glClear(mask); 469 } 470 471 void GraphicsContext3D::clearDepth(GC3Dclampf depth) 472 { 473 makeContextCurrent(); 474 ::glClearDepth(depth); 475 } 476 477 void GraphicsContext3D::clearStencil(GC3Dint s) 478 { 479 makeContextCurrent(); 480 ::glClearStencil(s); 481 } 482 483 void GraphicsContext3D::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha) 484 { 485 makeContextCurrent(); 486 ::glColorMask(red, green, blue, alpha); 487 } 488 489 void GraphicsContext3D::compileShader(Platform3DObject shader) 490 { 491 ASSERT(shader); 492 makeContextCurrent(); 493 494 int GLshaderType; 495 ANGLEShaderType shaderType; 496 497 glGetShaderiv(shader, SHADER_TYPE, &GLshaderType); 498 499 if (GLshaderType == VERTEX_SHADER) 500 shaderType = SHADER_TYPE_VERTEX; 501 else if (GLshaderType == FRAGMENT_SHADER) 502 shaderType = SHADER_TYPE_FRAGMENT; 503 else 504 return; // Invalid shader type. 505 506 HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); 507 508 if (result == m_shaderSourceMap.end()) 509 return; 510 511 ShaderSourceEntry& entry = result->second; 512 513 String translatedShaderSource; 514 String shaderInfoLog; 515 516 bool isValid = m_compiler.validateShaderSource(entry.source.utf8().data(), shaderType, translatedShaderSource, shaderInfoLog); 517 518 entry.log = shaderInfoLog; 519 entry.isValid = isValid; 520 521 if (!isValid) 522 return; // Shader didn't validate, don't move forward with compiling translated source 523 524 int translatedShaderLength = translatedShaderSource.length(); 525 526 const CString& translatedShaderCString = translatedShaderSource.utf8(); 527 const char* translatedShaderPtr = translatedShaderCString.data(); 528 529 ::glShaderSource(shader, 1, &translatedShaderPtr, &translatedShaderLength); 530 531 ::glCompileShader(shader); 532 533 int GLCompileSuccess; 534 535 ::glGetShaderiv(shader, COMPILE_STATUS, &GLCompileSuccess); 536 537 // ASSERT that ANGLE generated GLSL will be accepted by OpenGL 538 ASSERT(GLCompileSuccess == GL_TRUE); 539 } 540 541 void GraphicsContext3D::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) 542 { 543 makeContextCurrent(); 544 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) { 545 ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO); 546 ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo); 547 ::glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR); 548 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 549 } 550 ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); 551 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) 552 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO); 553 } 554 555 void GraphicsContext3D::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height) 556 { 557 makeContextCurrent(); 558 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) { 559 ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO); 560 ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo); 561 ::glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR); 562 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 563 } 564 ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); 565 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) 566 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO); 567 } 568 569 void GraphicsContext3D::cullFace(GC3Denum mode) 570 { 571 makeContextCurrent(); 572 ::glCullFace(mode); 573 } 574 575 void GraphicsContext3D::depthFunc(GC3Denum func) 576 { 577 makeContextCurrent(); 578 ::glDepthFunc(func); 579 } 580 581 void GraphicsContext3D::depthMask(GC3Dboolean flag) 582 { 583 makeContextCurrent(); 584 ::glDepthMask(flag); 585 } 586 587 void GraphicsContext3D::depthRange(GC3Dclampf zNear, GC3Dclampf zFar) 588 { 589 makeContextCurrent(); 590 ::glDepthRange(zNear, zFar); 591 } 592 593 void GraphicsContext3D::detachShader(Platform3DObject program, Platform3DObject shader) 594 { 595 ASSERT(program); 596 ASSERT(shader); 597 makeContextCurrent(); 598 ::glDetachShader(program, shader); 599 } 600 601 void GraphicsContext3D::disable(GC3Denum cap) 602 { 603 makeContextCurrent(); 604 ::glDisable(cap); 605 } 606 607 void GraphicsContext3D::disableVertexAttribArray(GC3Duint index) 608 { 609 makeContextCurrent(); 610 ::glDisableVertexAttribArray(index); 611 } 612 613 void GraphicsContext3D::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count) 614 { 615 makeContextCurrent(); 616 ::glDrawArrays(mode, first, count); 617 } 618 619 void GraphicsContext3D::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset) 620 { 621 makeContextCurrent(); 622 ::glDrawElements(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset))); 623 } 624 625 void GraphicsContext3D::enable(GC3Denum cap) 626 { 627 makeContextCurrent(); 628 ::glEnable(cap); 629 } 630 631 void GraphicsContext3D::enableVertexAttribArray(GC3Duint index) 632 { 633 makeContextCurrent(); 634 ::glEnableVertexAttribArray(index); 635 } 636 637 void GraphicsContext3D::finish() 638 { 639 makeContextCurrent(); 640 ::glFinish(); 641 } 642 643 void GraphicsContext3D::flush() 644 { 645 makeContextCurrent(); 646 ::glFlush(); 647 } 648 649 void GraphicsContext3D::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, Platform3DObject buffer) 650 { 651 makeContextCurrent(); 652 ::glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, buffer); 653 } 654 655 void GraphicsContext3D::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, Platform3DObject texture, GC3Dint level) 656 { 657 makeContextCurrent(); 658 ::glFramebufferTexture2DEXT(target, attachment, textarget, texture, level); 659 } 660 661 void GraphicsContext3D::frontFace(GC3Denum mode) 662 { 663 makeContextCurrent(); 664 ::glFrontFace(mode); 665 } 666 667 void GraphicsContext3D::generateMipmap(GC3Denum target) 668 { 669 makeContextCurrent(); 670 ::glGenerateMipmapEXT(target); 671 } 672 673 bool GraphicsContext3D::getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo& info) 674 { 675 if (!program) { 676 synthesizeGLError(INVALID_VALUE); 677 return false; 678 } 679 makeContextCurrent(); 680 GLint maxAttributeSize = 0; 681 ::glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxAttributeSize); 682 GLchar name[maxAttributeSize]; // GL_ACTIVE_ATTRIBUTE_MAX_LENGTH includes null termination 683 GLsizei nameLength = 0; 684 GLint size = 0; 685 GLenum type = 0; 686 ::glGetActiveAttrib(program, index, maxAttributeSize, &nameLength, &size, &type, name); 687 if (!nameLength) 688 return false; 689 info.name = String(name, nameLength); 690 info.type = type; 691 info.size = size; 692 return true; 693 } 694 695 bool GraphicsContext3D::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info) 696 { 697 if (!program) { 698 synthesizeGLError(INVALID_VALUE); 699 return false; 700 } 701 makeContextCurrent(); 702 GLint maxUniformSize = 0; 703 ::glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformSize); 704 GLchar name[maxUniformSize]; // GL_ACTIVE_UNIFORM_MAX_LENGTH includes null termination 705 GLsizei nameLength = 0; 706 GLint size = 0; 707 GLenum type = 0; 708 ::glGetActiveUniform(program, index, maxUniformSize, &nameLength, &size, &type, name); 709 if (!nameLength) 710 return false; 711 info.name = String(name, nameLength); 712 info.type = type; 713 info.size = size; 714 return true; 715 } 716 717 void GraphicsContext3D::getAttachedShaders(Platform3DObject program, GC3Dsizei maxCount, GC3Dsizei* count, Platform3DObject* shaders) 718 { 719 if (!program) { 720 synthesizeGLError(INVALID_VALUE); 721 return; 722 } 723 makeContextCurrent(); 724 ::glGetAttachedShaders(program, maxCount, count, shaders); 725 } 726 727 int GraphicsContext3D::getAttribLocation(Platform3DObject program, const String& name) 728 { 729 if (!program) 730 return -1; 731 732 makeContextCurrent(); 733 return ::glGetAttribLocation(program, name.utf8().data()); 734 } 735 736 GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes() 737 { 738 return m_attrs; 739 } 740 741 GC3Denum GraphicsContext3D::getError() 742 { 743 if (m_syntheticErrors.size() > 0) { 744 ListHashSet<GC3Denum>::iterator iter = m_syntheticErrors.begin(); 745 GC3Denum err = *iter; 746 m_syntheticErrors.remove(iter); 747 return err; 748 } 749 750 makeContextCurrent(); 751 return ::glGetError(); 752 } 753 754 String GraphicsContext3D::getString(GC3Denum name) 755 { 756 makeContextCurrent(); 757 return String((const char*) ::glGetString(name)); 758 } 759 760 void GraphicsContext3D::hint(GC3Denum target, GC3Denum mode) 761 { 762 makeContextCurrent(); 763 ::glHint(target, mode); 764 } 765 766 GC3Dboolean GraphicsContext3D::isBuffer(Platform3DObject buffer) 767 { 768 if (!buffer) 769 return GL_FALSE; 770 771 makeContextCurrent(); 772 return ::glIsBuffer(buffer); 773 } 774 775 GC3Dboolean GraphicsContext3D::isEnabled(GC3Denum cap) 776 { 777 makeContextCurrent(); 778 return ::glIsEnabled(cap); 779 } 780 781 GC3Dboolean GraphicsContext3D::isFramebuffer(Platform3DObject framebuffer) 782 { 783 if (!framebuffer) 784 return GL_FALSE; 785 786 makeContextCurrent(); 787 return ::glIsFramebufferEXT(framebuffer); 788 } 789 790 GC3Dboolean GraphicsContext3D::isProgram(Platform3DObject program) 791 { 792 if (!program) 793 return GL_FALSE; 794 795 makeContextCurrent(); 796 return ::glIsProgram(program); 797 } 798 799 GC3Dboolean GraphicsContext3D::isRenderbuffer(Platform3DObject renderbuffer) 800 { 801 if (!renderbuffer) 802 return GL_FALSE; 803 804 makeContextCurrent(); 805 return ::glIsRenderbufferEXT(renderbuffer); 806 } 807 808 GC3Dboolean GraphicsContext3D::isShader(Platform3DObject shader) 809 { 810 if (!shader) 811 return GL_FALSE; 812 813 makeContextCurrent(); 814 return ::glIsShader(shader); 815 } 816 817 GC3Dboolean GraphicsContext3D::isTexture(Platform3DObject texture) 818 { 819 if (!texture) 820 return GL_FALSE; 821 822 makeContextCurrent(); 823 return ::glIsTexture(texture); 824 } 825 826 void GraphicsContext3D::lineWidth(GC3Dfloat width) 827 { 828 makeContextCurrent(); 829 ::glLineWidth(width); 830 } 831 832 void GraphicsContext3D::linkProgram(Platform3DObject program) 833 { 834 ASSERT(program); 835 makeContextCurrent(); 836 ::glLinkProgram(program); 837 } 838 839 void GraphicsContext3D::pixelStorei(GC3Denum pname, GC3Dint param) 840 { 841 makeContextCurrent(); 842 ::glPixelStorei(pname, param); 843 } 844 845 void GraphicsContext3D::polygonOffset(GC3Dfloat factor, GC3Dfloat units) 846 { 847 makeContextCurrent(); 848 ::glPolygonOffset(factor, units); 849 } 850 851 void GraphicsContext3D::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data) 852 { 853 // FIXME: remove the two glFlush calls when the driver bug is fixed, i.e., 854 // all previous rendering calls should be done before reading pixels. 855 makeContextCurrent(); 856 ::glFlush(); 857 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) { 858 ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO); 859 ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo); 860 ::glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR); 861 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); 862 ::glFlush(); 863 } 864 ::glReadPixels(x, y, width, height, format, type, data); 865 if (m_attrs.antialias && m_boundFBO == m_multisampleFBO) 866 ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO); 867 } 868 869 void GraphicsContext3D::releaseShaderCompiler() 870 { 871 // FIXME: This is not implemented on desktop OpenGL. We need to have ifdefs for the different GL variants 872 makeContextCurrent(); 873 //::glReleaseShaderCompiler(); 874 } 875 876 void GraphicsContext3D::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) 877 { 878 makeContextCurrent(); 879 switch (internalformat) { 880 case DEPTH_STENCIL: 881 internalformat = GL_DEPTH24_STENCIL8_EXT; 882 break; 883 case DEPTH_COMPONENT16: 884 internalformat = GL_DEPTH_COMPONENT; 885 break; 886 case RGBA4: 887 case RGB5_A1: 888 internalformat = GL_RGBA; 889 break; 890 case RGB565: 891 internalformat = GL_RGB; 892 break; 893 } 894 ::glRenderbufferStorageEXT(target, internalformat, width, height); 895 } 896 897 void GraphicsContext3D::sampleCoverage(GC3Dclampf value, GC3Dboolean invert) 898 { 899 makeContextCurrent(); 900 ::glSampleCoverage(value, invert); 901 } 902 903 void GraphicsContext3D::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height) 904 { 905 makeContextCurrent(); 906 ::glScissor(x, y, width, height); 907 } 908 909 void GraphicsContext3D::shaderSource(Platform3DObject shader, const String& string) 910 { 911 ASSERT(shader); 912 913 makeContextCurrent(); 914 915 ShaderSourceEntry entry; 916 917 entry.source = string; 918 919 m_shaderSourceMap.set(shader, entry); 920 } 921 922 void GraphicsContext3D::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask) 923 { 924 makeContextCurrent(); 925 ::glStencilFunc(func, ref, mask); 926 } 927 928 void GraphicsContext3D::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask) 929 { 930 makeContextCurrent(); 931 ::glStencilFuncSeparate(face, func, ref, mask); 932 } 933 934 void GraphicsContext3D::stencilMask(GC3Duint mask) 935 { 936 makeContextCurrent(); 937 ::glStencilMask(mask); 938 } 939 940 void GraphicsContext3D::stencilMaskSeparate(GC3Denum face, GC3Duint mask) 941 { 942 makeContextCurrent(); 943 ::glStencilMaskSeparate(face, mask); 944 } 945 946 void GraphicsContext3D::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass) 947 { 948 makeContextCurrent(); 949 ::glStencilOp(fail, zfail, zpass); 950 } 951 952 void GraphicsContext3D::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass) 953 { 954 makeContextCurrent(); 955 ::glStencilOpSeparate(face, fail, zfail, zpass); 956 } 957 958 void GraphicsContext3D::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat value) 959 { 960 makeContextCurrent(); 961 ::glTexParameterf(target, pname, value); 962 } 963 964 void GraphicsContext3D::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint value) 965 { 966 makeContextCurrent(); 967 ::glTexParameteri(target, pname, value); 968 } 969 970 void GraphicsContext3D::uniform1f(GC3Dint location, GC3Dfloat v0) 971 { 972 makeContextCurrent(); 973 ::glUniform1f(location, v0); 974 } 975 976 void GraphicsContext3D::uniform1fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size) 977 { 978 makeContextCurrent(); 979 ::glUniform1fv(location, size, array); 980 } 981 982 void GraphicsContext3D::uniform2f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1) 983 { 984 makeContextCurrent(); 985 ::glUniform2f(location, v0, v1); 986 } 987 988 void GraphicsContext3D::uniform2fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size) 989 { 990 // FIXME: length needs to be a multiple of 2 991 makeContextCurrent(); 992 ::glUniform2fv(location, size, array); 993 } 994 995 void GraphicsContext3D::uniform3f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2) 996 { 997 makeContextCurrent(); 998 ::glUniform3f(location, v0, v1, v2); 999 } 1000 1001 void GraphicsContext3D::uniform3fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size) 1002 { 1003 // FIXME: length needs to be a multiple of 3 1004 makeContextCurrent(); 1005 ::glUniform3fv(location, size, array); 1006 } 1007 1008 void GraphicsContext3D::uniform4f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3) 1009 { 1010 makeContextCurrent(); 1011 ::glUniform4f(location, v0, v1, v2, v3); 1012 } 1013 1014 void GraphicsContext3D::uniform4fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size) 1015 { 1016 // FIXME: length needs to be a multiple of 4 1017 makeContextCurrent(); 1018 ::glUniform4fv(location, size, array); 1019 } 1020 1021 void GraphicsContext3D::uniform1i(GC3Dint location, GC3Dint v0) 1022 { 1023 makeContextCurrent(); 1024 ::glUniform1i(location, v0); 1025 } 1026 1027 void GraphicsContext3D::uniform1iv(GC3Dint location, GC3Dint* array, GC3Dsizei size) 1028 { 1029 makeContextCurrent(); 1030 ::glUniform1iv(location, size, array); 1031 } 1032 1033 void GraphicsContext3D::uniform2i(GC3Dint location, GC3Dint v0, GC3Dint v1) 1034 { 1035 makeContextCurrent(); 1036 ::glUniform2i(location, v0, v1); 1037 } 1038 1039 void GraphicsContext3D::uniform2iv(GC3Dint location, GC3Dint* array, GC3Dsizei size) 1040 { 1041 // FIXME: length needs to be a multiple of 2 1042 makeContextCurrent(); 1043 ::glUniform2iv(location, size, array); 1044 } 1045 1046 void GraphicsContext3D::uniform3i(GC3Dint location, GC3Dint v0, GC3Dint v1, GC3Dint v2) 1047 { 1048 makeContextCurrent(); 1049 ::glUniform3i(location, v0, v1, v2); 1050 } 1051 1052 void GraphicsContext3D::uniform3iv(GC3Dint location, GC3Dint* array, GC3Dsizei size) 1053 { 1054 // FIXME: length needs to be a multiple of 3 1055 makeContextCurrent(); 1056 ::glUniform3iv(location, size, array); 1057 } 1058 1059 void GraphicsContext3D::uniform4i(GC3Dint location, GC3Dint v0, GC3Dint v1, GC3Dint v2, GC3Dint v3) 1060 { 1061 makeContextCurrent(); 1062 ::glUniform4i(location, v0, v1, v2, v3); 1063 } 1064 1065 void GraphicsContext3D::uniform4iv(GC3Dint location, GC3Dint* array, GC3Dsizei size) 1066 { 1067 // FIXME: length needs to be a multiple of 4 1068 makeContextCurrent(); 1069 ::glUniform4iv(location, size, array); 1070 } 1071 1072 void GraphicsContext3D::uniformMatrix2fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size) 1073 { 1074 // FIXME: length needs to be a multiple of 4 1075 makeContextCurrent(); 1076 ::glUniformMatrix2fv(location, size, transpose, array); 1077 } 1078 1079 void GraphicsContext3D::uniformMatrix3fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size) 1080 { 1081 // FIXME: length needs to be a multiple of 9 1082 makeContextCurrent(); 1083 ::glUniformMatrix3fv(location, size, transpose, array); 1084 } 1085 1086 void GraphicsContext3D::uniformMatrix4fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size) 1087 { 1088 // FIXME: length needs to be a multiple of 16 1089 makeContextCurrent(); 1090 ::glUniformMatrix4fv(location, size, transpose, array); 1091 } 1092 1093 void GraphicsContext3D::useProgram(Platform3DObject program) 1094 { 1095 makeContextCurrent(); 1096 ::glUseProgram(program); 1097 } 1098 1099 void GraphicsContext3D::validateProgram(Platform3DObject program) 1100 { 1101 ASSERT(program); 1102 1103 makeContextCurrent(); 1104 ::glValidateProgram(program); 1105 } 1106 1107 void GraphicsContext3D::vertexAttrib1f(GC3Duint index, GC3Dfloat v0) 1108 { 1109 makeContextCurrent(); 1110 ::glVertexAttrib1f(index, v0); 1111 } 1112 1113 void GraphicsContext3D::vertexAttrib1fv(GC3Duint index, GC3Dfloat* array) 1114 { 1115 makeContextCurrent(); 1116 ::glVertexAttrib1fv(index, array); 1117 } 1118 1119 void GraphicsContext3D::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1) 1120 { 1121 makeContextCurrent(); 1122 ::glVertexAttrib2f(index, v0, v1); 1123 } 1124 1125 void GraphicsContext3D::vertexAttrib2fv(GC3Duint index, GC3Dfloat* array) 1126 { 1127 makeContextCurrent(); 1128 ::glVertexAttrib2fv(index, array); 1129 } 1130 1131 void GraphicsContext3D::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2) 1132 { 1133 makeContextCurrent(); 1134 ::glVertexAttrib3f(index, v0, v1, v2); 1135 } 1136 1137 void GraphicsContext3D::vertexAttrib3fv(GC3Duint index, GC3Dfloat* array) 1138 { 1139 makeContextCurrent(); 1140 ::glVertexAttrib3fv(index, array); 1141 } 1142 1143 void GraphicsContext3D::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3) 1144 { 1145 makeContextCurrent(); 1146 ::glVertexAttrib4f(index, v0, v1, v2, v3); 1147 } 1148 1149 void GraphicsContext3D::vertexAttrib4fv(GC3Duint index, GC3Dfloat* array) 1150 { 1151 makeContextCurrent(); 1152 ::glVertexAttrib4fv(index, array); 1153 } 1154 1155 void GraphicsContext3D::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, GC3Dintptr offset) 1156 { 1157 makeContextCurrent(); 1158 ::glVertexAttribPointer(index, size, type, normalized, stride, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset))); 1159 } 1160 1161 void GraphicsContext3D::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height) 1162 { 1163 makeContextCurrent(); 1164 ::glViewport(x, y, width, height); 1165 } 1166 1167 void GraphicsContext3D::getBooleanv(GC3Denum pname, GC3Dboolean* value) 1168 { 1169 makeContextCurrent(); 1170 ::glGetBooleanv(pname, value); 1171 } 1172 1173 void GraphicsContext3D::getBufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value) 1174 { 1175 makeContextCurrent(); 1176 ::glGetBufferParameteriv(target, pname, value); 1177 } 1178 1179 void GraphicsContext3D::getFloatv(GC3Denum pname, GC3Dfloat* value) 1180 { 1181 makeContextCurrent(); 1182 ::glGetFloatv(pname, value); 1183 } 1184 1185 void GraphicsContext3D::getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum pname, GC3Dint* value) 1186 { 1187 makeContextCurrent(); 1188 if (attachment == DEPTH_STENCIL_ATTACHMENT) 1189 attachment = DEPTH_ATTACHMENT; // Or STENCIL_ATTACHMENT, either works. 1190 ::glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, value); 1191 } 1192 1193 void GraphicsContext3D::getIntegerv(GC3Denum pname, GC3Dint* value) 1194 { 1195 // Need to emulate MAX_FRAGMENT/VERTEX_UNIFORM_VECTORS and MAX_VARYING_VECTORS 1196 // because desktop GL's corresponding queries return the number of components 1197 // whereas GLES2 return the number of vectors (each vector has 4 components). 1198 // Therefore, the value returned by desktop GL needs to be divided by 4. 1199 makeContextCurrent(); 1200 switch (pname) { 1201 case MAX_FRAGMENT_UNIFORM_VECTORS: 1202 ::glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, value); 1203 *value /= 4; 1204 break; 1205 case MAX_VERTEX_UNIFORM_VECTORS: 1206 ::glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, value); 1207 *value /= 4; 1208 break; 1209 case MAX_VARYING_VECTORS: 1210 ::glGetIntegerv(GL_MAX_VARYING_FLOATS, value); 1211 *value /= 4; 1212 break; 1213 default: 1214 ::glGetIntegerv(pname, value); 1215 } 1216 } 1217 1218 void GraphicsContext3D::getProgramiv(Platform3DObject program, GC3Denum pname, GC3Dint* value) 1219 { 1220 makeContextCurrent(); 1221 ::glGetProgramiv(program, pname, value); 1222 } 1223 1224 String GraphicsContext3D::getProgramInfoLog(Platform3DObject program) 1225 { 1226 ASSERT(program); 1227 1228 makeContextCurrent(); 1229 GLint length; 1230 ::glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); 1231 if (!length) 1232 return ""; 1233 1234 GLsizei size; 1235 GLchar* info = (GLchar*) fastMalloc(length); 1236 1237 ::glGetProgramInfoLog(program, length, &size, info); 1238 String s(info); 1239 fastFree(info); 1240 return s; 1241 } 1242 1243 void GraphicsContext3D::getRenderbufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value) 1244 { 1245 makeContextCurrent(); 1246 ::glGetRenderbufferParameterivEXT(target, pname, value); 1247 } 1248 1249 void GraphicsContext3D::getShaderiv(Platform3DObject shader, GC3Denum pname, GC3Dint* value) 1250 { 1251 ASSERT(shader); 1252 1253 makeContextCurrent(); 1254 1255 HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); 1256 1257 switch (pname) { 1258 case DELETE_STATUS: 1259 case SHADER_TYPE: 1260 // Let OpenGL handle these. 1261 1262 ::glGetShaderiv(shader, pname, value); 1263 break; 1264 1265 case COMPILE_STATUS: 1266 if (result == m_shaderSourceMap.end()) { 1267 (*value) = static_cast<int>(false); 1268 return; 1269 } 1270 1271 (*value) = static_cast<int>(result->second.isValid); 1272 break; 1273 1274 case INFO_LOG_LENGTH: 1275 if (result == m_shaderSourceMap.end()) { 1276 (*value) = 0; 1277 return; 1278 } 1279 1280 (*value) = getShaderInfoLog(shader).length(); 1281 break; 1282 1283 case SHADER_SOURCE_LENGTH: 1284 (*value) = getShaderSource(shader).length(); 1285 break; 1286 1287 default: 1288 synthesizeGLError(INVALID_ENUM); 1289 } 1290 } 1291 1292 String GraphicsContext3D::getShaderInfoLog(Platform3DObject shader) 1293 { 1294 ASSERT(shader); 1295 1296 makeContextCurrent(); 1297 1298 HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); 1299 1300 if (result == m_shaderSourceMap.end()) 1301 return ""; 1302 1303 ShaderSourceEntry entry = result->second; 1304 1305 if (entry.isValid) { 1306 GLint length; 1307 ::glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); 1308 if (!length) 1309 return ""; 1310 1311 GLsizei size; 1312 GLchar* info = (GLchar*) fastMalloc(length); 1313 1314 ::glGetShaderInfoLog(shader, length, &size, info); 1315 1316 String s(info); 1317 fastFree(info); 1318 return s; 1319 } else 1320 return entry.log; 1321 } 1322 1323 String GraphicsContext3D::getShaderSource(Platform3DObject shader) 1324 { 1325 ASSERT(shader); 1326 1327 makeContextCurrent(); 1328 1329 HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); 1330 1331 if (result == m_shaderSourceMap.end()) 1332 return ""; 1333 1334 return result->second.source; 1335 } 1336 1337 1338 void GraphicsContext3D::getTexParameterfv(GC3Denum target, GC3Denum pname, GC3Dfloat* value) 1339 { 1340 makeContextCurrent(); 1341 ::glGetTexParameterfv(target, pname, value); 1342 } 1343 1344 void GraphicsContext3D::getTexParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value) 1345 { 1346 makeContextCurrent(); 1347 ::glGetTexParameteriv(target, pname, value); 1348 } 1349 1350 void GraphicsContext3D::getUniformfv(Platform3DObject program, GC3Dint location, GC3Dfloat* value) 1351 { 1352 makeContextCurrent(); 1353 ::glGetUniformfv(program, location, value); 1354 } 1355 1356 void GraphicsContext3D::getUniformiv(Platform3DObject program, GC3Dint location, GC3Dint* value) 1357 { 1358 makeContextCurrent(); 1359 ::glGetUniformiv(program, location, value); 1360 } 1361 1362 GC3Dint GraphicsContext3D::getUniformLocation(Platform3DObject program, const String& name) 1363 { 1364 ASSERT(program); 1365 1366 makeContextCurrent(); 1367 return ::glGetUniformLocation(program, name.utf8().data()); 1368 } 1369 1370 void GraphicsContext3D::getVertexAttribfv(GC3Duint index, GC3Denum pname, GC3Dfloat* value) 1371 { 1372 makeContextCurrent(); 1373 ::glGetVertexAttribfv(index, pname, value); 1374 } 1375 1376 void GraphicsContext3D::getVertexAttribiv(GC3Duint index, GC3Denum pname, GC3Dint* value) 1377 { 1378 makeContextCurrent(); 1379 ::glGetVertexAttribiv(index, pname, value); 1380 } 1381 1382 GC3Dsizeiptr GraphicsContext3D::getVertexAttribOffset(GC3Duint index, GC3Denum pname) 1383 { 1384 makeContextCurrent(); 1385 1386 GLvoid* pointer = 0; 1387 ::glGetVertexAttribPointerv(index, pname, &pointer); 1388 return static_cast<GC3Dsizeiptr>(reinterpret_cast<intptr_t>(pointer)); 1389 } 1390 1391 bool GraphicsContext3D::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels) 1392 { 1393 if (width && height && !pixels) { 1394 synthesizeGLError(INVALID_VALUE); 1395 return false; 1396 } 1397 makeContextCurrent(); 1398 GC3Denum openGLInternalFormat = internalformat; 1399 if (type == GL_FLOAT) { 1400 if (format == GL_RGBA) 1401 openGLInternalFormat = GL_RGBA32F_ARB; 1402 else if (format == GL_RGB) 1403 openGLInternalFormat = GL_RGB32F_ARB; 1404 } 1405 1406 ::glTexImage2D(target, level, openGLInternalFormat, width, height, border, format, type, pixels); 1407 return true; 1408 } 1409 1410 void GraphicsContext3D::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoff, GC3Dint yoff, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels) 1411 { 1412 makeContextCurrent(); 1413 1414 // FIXME: we will need to deal with PixelStore params when dealing with image buffers that differ from the subimage size 1415 ::glTexSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels); 1416 } 1417 1418 Platform3DObject GraphicsContext3D::createBuffer() 1419 { 1420 makeContextCurrent(); 1421 GLuint o = 0; 1422 glGenBuffers(1, &o); 1423 return o; 1424 } 1425 1426 Platform3DObject GraphicsContext3D::createFramebuffer() 1427 { 1428 makeContextCurrent(); 1429 GLuint o = 0; 1430 glGenFramebuffersEXT(1, &o); 1431 return o; 1432 } 1433 1434 Platform3DObject GraphicsContext3D::createProgram() 1435 { 1436 makeContextCurrent(); 1437 return glCreateProgram(); 1438 } 1439 1440 Platform3DObject GraphicsContext3D::createRenderbuffer() 1441 { 1442 makeContextCurrent(); 1443 GLuint o = 0; 1444 glGenRenderbuffersEXT(1, &o); 1445 return o; 1446 } 1447 1448 Platform3DObject GraphicsContext3D::createShader(GC3Denum type) 1449 { 1450 makeContextCurrent(); 1451 return glCreateShader((type == FRAGMENT_SHADER) ? GL_FRAGMENT_SHADER : GL_VERTEX_SHADER); 1452 } 1453 1454 Platform3DObject GraphicsContext3D::createTexture() 1455 { 1456 makeContextCurrent(); 1457 GLuint o = 0; 1458 glGenTextures(1, &o); 1459 return o; 1460 } 1461 1462 void GraphicsContext3D::deleteBuffer(Platform3DObject buffer) 1463 { 1464 makeContextCurrent(); 1465 glDeleteBuffers(1, &buffer); 1466 } 1467 1468 void GraphicsContext3D::deleteFramebuffer(Platform3DObject framebuffer) 1469 { 1470 makeContextCurrent(); 1471 glDeleteFramebuffersEXT(1, &framebuffer); 1472 } 1473 1474 void GraphicsContext3D::deleteProgram(Platform3DObject program) 1475 { 1476 makeContextCurrent(); 1477 glDeleteProgram(program); 1478 } 1479 1480 void GraphicsContext3D::deleteRenderbuffer(Platform3DObject renderbuffer) 1481 { 1482 makeContextCurrent(); 1483 glDeleteRenderbuffersEXT(1, &renderbuffer); 1484 } 1485 1486 void GraphicsContext3D::deleteShader(Platform3DObject shader) 1487 { 1488 makeContextCurrent(); 1489 glDeleteShader(shader); 1490 } 1491 1492 void GraphicsContext3D::deleteTexture(Platform3DObject texture) 1493 { 1494 makeContextCurrent(); 1495 glDeleteTextures(1, &texture); 1496 } 1497 1498 void GraphicsContext3D::synthesizeGLError(GC3Denum error) 1499 { 1500 m_syntheticErrors.add(error); 1501 } 1502 1503 void GraphicsContext3D::markContextChanged() 1504 { 1505 m_layerComposited = false; 1506 } 1507 1508 void GraphicsContext3D::markLayerComposited() 1509 { 1510 m_layerComposited = true; 1511 } 1512 1513 bool GraphicsContext3D::layerComposited() const 1514 { 1515 return m_layerComposited; 1516 } 1517 1518 Extensions3D* GraphicsContext3D::getExtensions() 1519 { 1520 if (!m_extensions) 1521 m_extensions = adoptPtr(new Extensions3DOpenGL(this)); 1522 return m_extensions.get(); 1523 } 1524 1525 } 1526 1527 #endif // ENABLE(WEBGL) 1528
