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 #include "config.h"

    27 

    28 #if ENABLE(3D_CANVAS)

    29 

    30 #include "WebGLRenderingContext.h"

    31 

    32 #include "CheckedInt.h"

    33 #include "CanvasPixelArray.h"

    34 #include "Console.h"

    35 #include "DOMWindow.h"

    36 #include "FrameView.h"

    37 #include "HTMLCanvasElement.h"

    38 #include "HTMLImageElement.h"

    39 #include "ImageBuffer.h"

    40 #include "ImageData.h"

    41 #include "NotImplemented.h"

    42 #include "RenderBox.h"

    43 #include "RenderLayer.h"

    44 #include "WebGLActiveInfo.h"

    45 #include "Uint16Array.h"

    46 #include "WebGLBuffer.h"

    47 #include "WebGLContextAttributes.h"

    48 #include "WebGLFramebuffer.h"

    49 #include "WebGLProgram.h"

    50 #include "WebGLRenderbuffer.h"

    51 #include "WebGLTexture.h"

    52 #include "WebGLShader.h"

    53 #include "WebGLUniformLocation.h"

    54 

    55 #include <wtf/ByteArray.h>

    56 #include <wtf/OwnArrayPtr.h>

    57 

    58 namespace WebCore {

    59 

    60 class WebGLStateRestorer {

    61 public:

    62     WebGLStateRestorer(WebGLRenderingContext* context,

    63                        bool changed)

    64         : m_context(context)

    65         , m_changed(changed)

    66     {

    67     }

    68 

    69     ~WebGLStateRestorer()

    70     {

    71         m_context->cleanupAfterGraphicsCall(m_changed);

    72     }

    73 

    74 private:

    75     WebGLRenderingContext* m_context;

    76     bool m_changed;

    77 };

    78 

    79 PassOwnPtr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)

    80 {

    81     HostWindow* hostWindow = canvas->document()->view()->root()->hostWindow();

    82     OwnPtr<GraphicsContext3D> context(GraphicsContext3D::create(attrs->attributes(), hostWindow));

    83 

    84     if (!context)

    85         return 0;

    86         

    87     return new WebGLRenderingContext(canvas, context.release());

    88 }

    89 

    90 WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassOwnPtr<GraphicsContext3D> context)

    91     : CanvasRenderingContext(passedCanvas)

    92     , m_context(context)

    93     , m_needsUpdate(true)

    94     , m_markedCanvasDirty(false)

    95     , m_activeTextureUnit(0)

    96     , m_packAlignment(4)

    97     , m_unpackAlignment(4)

    98     , m_unpackFlipY(false)

    99     , m_unpackPremultiplyAlpha(false)

   100 {

   101     ASSERT(m_context);

   102 

   103     int numCombinedTextureImageUnits = 0;

   104     m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

   105     m_textureUnits.resize(numCombinedTextureImageUnits);

   106 

   107     int numVertexAttribs = 0;

   108     m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

   109     m_maxVertexAttribs = numVertexAttribs;

   110 

   111     int implementationColorReadFormat = GraphicsContext3D::RGBA;

   112     m_context->getIntegerv(GraphicsContext3D::IMPLEMENTATION_COLOR_READ_FORMAT, &implementationColorReadFormat);

   113     m_implementationColorReadFormat = implementationColorReadFormat;

   114     int implementationColorReadType = GraphicsContext3D::UNSIGNED_BYTE;

   115     m_context->getIntegerv(GraphicsContext3D::IMPLEMENTATION_COLOR_READ_TYPE, &implementationColorReadType);

   116     m_implementationColorReadType = implementationColorReadType;

   117 

   118     m_maxTextureSize = 0;

   119     m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

   120     m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

   121     m_maxCubeMapTextureSize = 0;

   122     m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

   123     m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

   124 

   125     if (!isGLES2Compliant()) {

   126         createFallbackBlackTextures1x1();

   127         initVertexAttrib0();

   128     }

   129     m_context->reshape(canvas()->width(), canvas()->height());

   130     m_context->viewport(0, 0, canvas()->width(), canvas()->height());

   131 }

   132 

   133 WebGLRenderingContext::~WebGLRenderingContext()

   134 {

   135     detachAndRemoveAllObjects();

   136 }

   137 

   138 void WebGLRenderingContext::markContextChanged()

   139 {

   140 #if USE(ACCELERATED_COMPOSITING)

   141     RenderBox* renderBox = canvas()->renderBox();

   142     if (renderBox && renderBox->hasLayer() && renderBox->layer()->hasAcceleratedCompositing())

   143         renderBox->layer()->rendererContentChanged();

   144 #endif

   145     if (!m_markedCanvasDirty) {

   146         // Make sure the canvas's image buffer is allocated.

   147         canvas()->buffer();

   148         canvas()->willDraw(FloatRect(0, 0, canvas()->width(), canvas()->height()));

   149         m_markedCanvasDirty = true;

   150     }

   151 }

   152 

   153 bool WebGLRenderingContext::paintRenderingResultsToCanvas()

   154 {

   155     if (m_markedCanvasDirty) {

   156         m_markedCanvasDirty = false;

   157         m_context->paintRenderingResultsToCanvas(this);

   158         return true;

   159     }

   160     return false;

   161 }

   162 

   163 void WebGLRenderingContext::beginPaint()

   164 {

   165     if (m_markedCanvasDirty) {

   166         m_context->beginPaint(this);

   167     }

   168 }

   169 

   170 void WebGLRenderingContext::endPaint()

   171 {

   172     if (m_markedCanvasDirty) {

   173         m_markedCanvasDirty = false;

   174         m_context->endPaint();

   175     }

   176 }

   177 

   178 void WebGLRenderingContext::reshape(int width, int height)

   179 {

   180     if (m_needsUpdate) {

   181 #if USE(ACCELERATED_COMPOSITING)

   182         RenderBox* renderBox = canvas()->renderBox();

   183         if (renderBox && renderBox->hasLayer())

   184             renderBox->layer()->rendererContentChanged();

   185 #endif

   186         m_needsUpdate = false;

   187     }

   188     

   189     m_context->reshape(width, height);

   190 }

   191 

   192 int WebGLRenderingContext::sizeInBytes(int type, ExceptionCode& ec)

   193 {

   194     UNUSED_PARAM(ec);

   195     int result = m_context->sizeInBytes(type);

   196     if (result <= 0)

   197         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   198 

   199     return result;

   200 }

   201 

   202 void WebGLRenderingContext::activeTexture(unsigned long texture, ExceptionCode& ec)

   203 {

   204     UNUSED_PARAM(ec);

   205     if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

   206         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   207         return;

   208     }

   209     m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

   210     m_context->activeTexture(texture);

   211     cleanupAfterGraphicsCall(false);

   212 }

   213 

   214 void WebGLRenderingContext::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

   215 {

   216     UNUSED_PARAM(ec);

   217     if (!validateWebGLObject(program) || !validateWebGLObject(shader))

   218         return;

   219     m_context->attachShader(program, shader);

   220     cleanupAfterGraphicsCall(false);

   221 }

   222 

   223 void WebGLRenderingContext::bindAttribLocation(WebGLProgram* program, unsigned long index, const String& name, ExceptionCode& ec)

   224 {

   225     UNUSED_PARAM(ec);

   226     if (!validateWebGLObject(program))

   227         return;

   228     m_context->bindAttribLocation(program, index, name);

   229     cleanupAfterGraphicsCall(false);

   230 }

   231 

   232 void WebGLRenderingContext::bindBuffer(unsigned long target, WebGLBuffer* buffer, ExceptionCode& ec)

   233 {

   234     UNUSED_PARAM(ec);

   235     if (buffer && buffer->context() != this) {

   236         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   237         return;

   238     }

   239     if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

   240         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   241         return;

   242     }

   243 

   244     if (target == GraphicsContext3D::ARRAY_BUFFER)

   245         m_boundArrayBuffer = buffer;

   246     else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

   247         m_boundElementArrayBuffer = buffer;

   248     else {

   249         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   250         return;

   251     }

   252 

   253     m_context->bindBuffer(target, buffer);

   254     if (buffer)

   255         buffer->setTarget(target);

   256     cleanupAfterGraphicsCall(false);

   257 }

   258 

   259 

   260 void WebGLRenderingContext::bindFramebuffer(unsigned long target, WebGLFramebuffer* buffer, ExceptionCode& ec)

   261 {

   262     UNUSED_PARAM(ec);

   263     if (buffer && buffer->context() != this) {

   264         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   265         return;

   266     }

   267     if (target != GraphicsContext3D::FRAMEBUFFER) {

   268         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   269         return;

   270     }

   271     m_framebufferBinding = buffer;

   272     m_context->bindFramebuffer(target, buffer);

   273     if (m_framebufferBinding)

   274         m_framebufferBinding->onBind();

   275     cleanupAfterGraphicsCall(false);

   276 }

   277 

   278 void WebGLRenderingContext::bindRenderbuffer(unsigned long target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

   279 {

   280     UNUSED_PARAM(ec);

   281     if (renderBuffer && renderBuffer->context() != this) {

   282         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   283         return;

   284     }

   285     if (target != GraphicsContext3D::RENDERBUFFER) {

   286         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   287         return;

   288     }

   289     m_renderbufferBinding = renderBuffer;

   290     m_context->bindRenderbuffer(target, renderBuffer);

   291     cleanupAfterGraphicsCall(false);

   292 }

   293 

   294 

   295 void WebGLRenderingContext::bindTexture(unsigned long target, WebGLTexture* texture, ExceptionCode& ec)

   296 {

   297     UNUSED_PARAM(ec);

   298     if (texture && texture->context() != this) {

   299         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   300         return;

   301     }

   302     int maxLevel = 0;

   303     if (target == GraphicsContext3D::TEXTURE_2D) {

   304         m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;

   305         maxLevel = m_maxTextureLevel;

   306     } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

   307         m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;

   308         maxLevel = m_maxCubeMapTextureLevel;

   309     } else {

   310         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   311         return;

   312     }

   313     m_context->bindTexture(target, texture);

   314     if (!isGLES2Compliant() && texture)

   315         texture->setTarget(target, maxLevel);

   316     cleanupAfterGraphicsCall(false);

   317 }

   318 

   319 void WebGLRenderingContext::blendColor(double red, double green, double blue, double alpha)

   320 {

   321     m_context->blendColor(red, green, blue, alpha);

   322     cleanupAfterGraphicsCall(false);

   323 }

   324 

   325 void WebGLRenderingContext::blendEquation( unsigned long mode )

   326 {

   327     if (!isGLES2Compliant()) {

   328         if (!validateBlendEquation(mode))

   329             return;

   330     }

   331     m_context->blendEquation(mode);

   332     cleanupAfterGraphicsCall(false);

   333 }

   334 

   335 void WebGLRenderingContext::blendEquationSeparate(unsigned long modeRGB, unsigned long modeAlpha)

   336 {

   337     if (!isGLES2Compliant()) {

   338         if (!validateBlendEquation(modeRGB) || !validateBlendEquation(modeAlpha))

   339             return;

   340     }

   341     m_context->blendEquationSeparate(modeRGB, modeAlpha);

   342     cleanupAfterGraphicsCall(false);

   343 }

   344 

   345 

   346 void WebGLRenderingContext::blendFunc(unsigned long sfactor, unsigned long dfactor)

   347 {

   348     m_context->blendFunc(sfactor, dfactor);

   349     cleanupAfterGraphicsCall(false);

   350 }       

   351 

   352 void WebGLRenderingContext::blendFuncSeparate(unsigned long srcRGB, unsigned long dstRGB, unsigned long srcAlpha, unsigned long dstAlpha)

   353 {

   354     m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

   355     cleanupAfterGraphicsCall(false);

   356 }

   357 

   358 void WebGLRenderingContext::bufferData(unsigned long target, int size, unsigned long usage, ExceptionCode& ec)

   359 {

   360     UNUSED_PARAM(ec);

   361     WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

   362     if (!buffer)

   363         return;

   364     if (!buffer->associateBufferData(size)) {

   365         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   366         return;

   367     }

   368 

   369     m_context->bufferData(target, size, usage);

   370     cleanupAfterGraphicsCall(false);

   371 }

   372 

   373 void WebGLRenderingContext::bufferData(unsigned long target, ArrayBuffer* data, unsigned long usage, ExceptionCode& ec)

   374 {

   375     UNUSED_PARAM(ec);

   376     WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

   377     if (!buffer)

   378         return;

   379     if (!buffer->associateBufferData(data)) {

   380         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   381         return;

   382     }

   383 

   384     m_context->bufferData(target, data, usage);

   385     cleanupAfterGraphicsCall(false);

   386 }

   387 

   388 void WebGLRenderingContext::bufferData(unsigned long target, ArrayBufferView* data, unsigned long usage, ExceptionCode& ec)

   389 {

   390     UNUSED_PARAM(ec);

   391     WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

   392     if (!buffer)

   393         return;

   394     if (!buffer->associateBufferData(data)) {

   395         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   396         return;

   397     }

   398 

   399     m_context->bufferData(target, data, usage);

   400     cleanupAfterGraphicsCall(false);

   401 }

   402 

   403 void WebGLRenderingContext::bufferSubData(unsigned long target, long offset, ArrayBuffer* data, ExceptionCode& ec)

   404 {

   405     UNUSED_PARAM(ec);

   406     WebGLBuffer* buffer = validateBufferDataParameters(target, GraphicsContext3D::STATIC_DRAW);

   407     if (!buffer)

   408         return;

   409     if (!buffer->associateBufferSubData(offset, data)) {

   410         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   411         return;

   412     }

   413 

   414     m_context->bufferSubData(target, offset, data);

   415     cleanupAfterGraphicsCall(false);

   416 }

   417 

   418 void WebGLRenderingContext::bufferSubData(unsigned long target, long offset, ArrayBufferView* data, ExceptionCode& ec)

   419 {

   420     UNUSED_PARAM(ec);

   421     WebGLBuffer* buffer = validateBufferDataParameters(target, GraphicsContext3D::STATIC_DRAW);

   422     if (!buffer)

   423         return;

   424     if (!buffer->associateBufferSubData(offset, data)) {

   425         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   426         return;

   427     }

   428 

   429     m_context->bufferSubData(target, offset, data);

   430     cleanupAfterGraphicsCall(false);

   431 }

   432 

   433 unsigned long WebGLRenderingContext::checkFramebufferStatus(unsigned long target)

   434 {

   435     if (!isGLES2Compliant()) {

   436         if (target != GraphicsContext3D::FRAMEBUFFER) {

   437             m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   438             return 0;

   439         }

   440     }

   441     if (!m_framebufferBinding || !m_framebufferBinding->object())

   442         return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

   443     return m_context->checkFramebufferStatus(target);

   444     cleanupAfterGraphicsCall(false);

   445 }

   446 

   447 void WebGLRenderingContext::clear(unsigned long mask)

   448 {

   449     if (!isGLES2Compliant()) {

   450         if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

   451             m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   452             return;

   453         }

   454     }

   455     m_context->clear(mask);

   456     cleanupAfterGraphicsCall(true);

   457 }

   458 

   459 void WebGLRenderingContext::clearColor(double r, double g, double b, double a)

   460 {

   461     if (isnan(r))

   462         r = 0;

   463     if (isnan(g))

   464         g = 0;

   465     if (isnan(b))

   466         b = 0;

   467     if (isnan(a))

   468         a = 1;

   469     m_context->clearColor(r, g, b, a);

   470     cleanupAfterGraphicsCall(false);

   471 }

   472 

   473 void WebGLRenderingContext::clearDepth(double depth)

   474 {

   475     m_context->clearDepth(depth);

   476     cleanupAfterGraphicsCall(false);

   477 }

   478 

   479 void WebGLRenderingContext::clearStencil(long s)

   480 {

   481     m_context->clearStencil(s);

   482     cleanupAfterGraphicsCall(false);

   483 }

   484 

   485 void WebGLRenderingContext::colorMask(bool red, bool green, bool blue, bool alpha)

   486 {

   487     m_context->colorMask(red, green, blue, alpha);

   488     cleanupAfterGraphicsCall(false);

   489 }

   490 

   491 void WebGLRenderingContext::compileShader(WebGLShader* shader, ExceptionCode& ec)

   492 {

   493     UNUSED_PARAM(ec);

   494     if (!validateWebGLObject(shader))

   495         return;

   496     m_context->compileShader(shader);

   497     cleanupAfterGraphicsCall(false);

   498 }

   499 

   500 void WebGLRenderingContext::copyTexImage2D(unsigned long target, long level, unsigned long internalformat, long x, long y, unsigned long width, unsigned long height, long border)

   501 {

   502     if (!validateTexFuncParameters(target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

   503         return;

   504     if (!isGLES2Compliant()) {

   505         if (m_framebufferBinding && m_framebufferBinding->object()

   506             && !isTexInternalFormatColorBufferCombinationValid(internalformat,

   507                                                                m_framebufferBinding->getColorBufferFormat())) {

   508             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   509             return;

   510         }

   511         if (level && WebGLTexture::isNPOT(width, height)) {

   512             m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   513             return;

   514         }

   515     }

   516     m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

   517     // FIXME: if the framebuffer is not complete, none of the below should be executed.

   518     WebGLTexture* tex = getTextureBinding(target);

   519     if (!isGLES2Compliant()) {

   520         if (tex)

   521             tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

   522     }

   523     if (m_framebufferBinding && tex)

   524         m_framebufferBinding->onAttachedObjectChange(tex);

   525     cleanupAfterGraphicsCall(false);

   526 }

   527 

   528 void WebGLRenderingContext::copyTexSubImage2D(unsigned long target, long level, long xoffset, long yoffset, long x, long y, unsigned long width, unsigned long height)

   529 {

   530     if (!isGLES2Compliant()) {

   531         WebGLTexture* tex = getTextureBinding(target);

   532         if (m_framebufferBinding && m_framebufferBinding->object() && tex

   533             && !isTexInternalFormatColorBufferCombinationValid(tex->getInternalFormat(),

   534                                                                m_framebufferBinding->getColorBufferFormat())) {

   535             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   536             return;

   537         }

   538     }

   539     m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

   540     cleanupAfterGraphicsCall(false);

   541 }

   542 

   543 PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()

   544 {

   545     RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);

   546     addObject(o.get());

   547     return o;

   548 }

   549         

   550 PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()

   551 {

   552     RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);

   553     addObject(o.get());

   554     return o;

   555 }

   556 

   557 PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()

   558 {

   559     RefPtr<WebGLTexture> o = WebGLTexture::create(this);

   560     addObject(o.get());

   561     return o;

   562 }

   563 

   564 PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()

   565 {

   566     RefPtr<WebGLProgram> o = WebGLProgram::create(this);

   567     addObject(o.get());

   568     return o;

   569 }

   570 

   571 PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()

   572 {

   573     RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);

   574     addObject(o.get());

   575     return o;

   576 }

   577 

   578 PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(unsigned long type, ExceptionCode& ec)

   579 {

   580     UNUSED_PARAM(ec);

   581     if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {

   582         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   583         return 0;

   584     }

   585     

   586     RefPtr<WebGLShader> o = WebGLShader::create(this, static_cast<GraphicsContext3D::WebGLEnumType>(type));

   587     addObject(o.get());

   588     return o;

   589 }

   590 

   591 void WebGLRenderingContext::cullFace(unsigned long mode)

   592 {

   593     m_context->cullFace(mode);

   594     cleanupAfterGraphicsCall(false);

   595 }

   596 

   597 void WebGLRenderingContext::deleteBuffer(WebGLBuffer* buffer)

   598 {

   599     if (!buffer)

   600         return;

   601     

   602     buffer->deleteObject();

   603 

   604     if (!isGLES2Compliant()) {

   605         VertexAttribState& state = m_vertexAttribState[0];

   606         if (buffer == state.bufferBinding) {

   607             state.bufferBinding = m_vertexAttrib0Buffer;

   608             state.bytesPerElement = 0;

   609             state.size = 4;

   610             state.type = GraphicsContext3D::FLOAT;

   611             state.normalized = false;

   612             state.stride = 16;

   613             state.originalStride = 0;

   614             state.offset = 0;

   615         }

   616     }

   617 }

   618 

   619 void WebGLRenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)

   620 {

   621     if (!framebuffer)

   622         return;

   623     

   624     framebuffer->deleteObject();

   625 }

   626 

   627 void WebGLRenderingContext::deleteProgram(WebGLProgram* program)

   628 {

   629     if (!program)

   630         return;

   631     

   632     program->deleteObject();

   633 }

   634 

   635 void WebGLRenderingContext::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)

   636 {

   637     if (!renderbuffer)

   638         return;

   639     

   640     renderbuffer->deleteObject();

   641     if (m_framebufferBinding)

   642         m_framebufferBinding->onAttachedObjectChange(renderbuffer);

   643 }

   644 

   645 void WebGLRenderingContext::deleteShader(WebGLShader* shader)

   646 {

   647     if (!shader)

   648         return;

   649     

   650     shader->deleteObject();

   651 }

   652 

   653 void WebGLRenderingContext::deleteTexture(WebGLTexture* texture)

   654 {

   655     if (!texture)

   656         return;

   657     

   658     texture->deleteObject();

   659     if (m_framebufferBinding)

   660         m_framebufferBinding->onAttachedObjectChange(texture);

   661 }

   662 

   663 void WebGLRenderingContext::depthFunc(unsigned long func)

   664 {

   665     m_context->depthFunc(func);

   666     cleanupAfterGraphicsCall(false);

   667 }

   668 

   669 void WebGLRenderingContext::depthMask(bool flag)

   670 {

   671     m_context->depthMask(flag);

   672     cleanupAfterGraphicsCall(false);

   673 }

   674 

   675 void WebGLRenderingContext::depthRange(double zNear, double zFar)

   676 {

   677     m_context->depthRange(zNear, zFar);

   678     cleanupAfterGraphicsCall(false);

   679 }

   680 

   681 void WebGLRenderingContext::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

   682 {

   683     UNUSED_PARAM(ec);

   684     if (!validateWebGLObject(program) || !validateWebGLObject(shader))

   685         return;

   686     m_context->detachShader(program, shader);

   687     cleanupAfterGraphicsCall(false);

   688 }

   689 

   690 

   691 void WebGLRenderingContext::disable(unsigned long cap)

   692 {

   693     if (!isGLES2Compliant()) {

   694         if (!validateCapability(cap))

   695             return;

   696     }

   697     m_context->disable(cap);

   698     cleanupAfterGraphicsCall(false);

   699 }

   700 

   701 void WebGLRenderingContext::disableVertexAttribArray(unsigned long index, ExceptionCode& ec)

   702 {

   703     UNUSED_PARAM(ec);

   704     if (index >= m_maxVertexAttribs) {

   705         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   706         return;

   707     }

   708     

   709     if (index < m_vertexAttribState.size())

   710         m_vertexAttribState[index].enabled = false;

   711 

   712     if (index > 0 || isGLES2Compliant()) {

   713         m_context->disableVertexAttribArray(index);

   714         cleanupAfterGraphicsCall(false);

   715     }

   716 }

   717 

   718 bool WebGLRenderingContext::validateElementArraySize(unsigned long count, unsigned long type, long offset)

   719 {

   720     if (!m_boundElementArrayBuffer)

   721         return false;

   722 

   723     if (offset < 0)

   724         return false;

   725 

   726     unsigned long uoffset = static_cast<unsigned long>(offset);

   727 

   728     if (type == GraphicsContext3D::UNSIGNED_SHORT) {

   729         // For an unsigned short array, offset must be divisible by 2 for alignment reasons.

   730         if (uoffset & 1)

   731             return false;

   732 

   733         // Make uoffset an element offset.

   734         uoffset /= 2;

   735 

   736         unsigned long n = m_boundElementArrayBuffer->byteLength() / 2;

   737         if (uoffset > n || count > n - uoffset)

   738             return false;

   739     } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

   740         unsigned long n = m_boundElementArrayBuffer->byteLength();

   741         if (uoffset > n || count > n - uoffset)

   742             return false;

   743     }

   744     return true;

   745 }

   746 

   747 bool WebGLRenderingContext::validateIndexArrayConservative(unsigned long type, long& numElementsRequired)

   748 {

   749     // Performs conservative validation by caching a maximum index of

   750     // the given type per element array buffer. If all of the bound

   751     // array buffers have enough elements to satisfy that maximum

   752     // index, skips the expensive per-draw-call iteration in

   753     // validateIndexArrayPrecise.

   754 

   755     long maxIndex = m_boundElementArrayBuffer->getCachedMaxIndex(type);

   756     if (maxIndex < 0) {

   757         // Compute the maximum index in the entire buffer for the given type of index.

   758         switch (type) {

   759         case GraphicsContext3D::UNSIGNED_BYTE: {

   760             unsigned numElements = m_boundElementArrayBuffer->byteLength();

   761             if (!numElements)

   762                 maxIndex = 0;

   763             else {

   764                 const unsigned char* p = static_cast<const unsigned char*>(m_boundElementArrayBuffer->elementArrayBuffer()->data());

   765                 for (unsigned i = 0; i < numElements; i++)

   766                     maxIndex = max(maxIndex, static_cast<long>(p[i]));

   767             }

   768             break;

   769         }

   770         case GraphicsContext3D::UNSIGNED_SHORT: {

   771             unsigned numElements = m_boundElementArrayBuffer->byteLength() / sizeof(unsigned short);

   772             if (!numElements)

   773                 maxIndex = 0;

   774             else {

   775                 const unsigned short* p = static_cast<const unsigned short*>(m_boundElementArrayBuffer->elementArrayBuffer()->data());

   776                 for (unsigned i = 0; i < numElements; i++)

   777                     maxIndex = max(maxIndex, static_cast<long>(p[i]));

   778             }

   779             break;

   780         }

   781         default:

   782             return false;

   783         }

   784         m_boundElementArrayBuffer->setCachedMaxIndex(type, maxIndex);

   785     }

   786 

   787     if (maxIndex >= 0) {

   788         // The number of required elements is one more than the maximum

   789         // index that will be accessed.

   790         numElementsRequired = maxIndex + 1;

   791         return true;

   792     }

   793 

   794     return false;

   795 }

   796 

   797 bool WebGLRenderingContext::validateIndexArrayPrecise(unsigned long count, unsigned long type, long offset, long& numElementsRequired)

   798 {

   799     long lastIndex = -1;

   800 

   801     if (!m_boundElementArrayBuffer)

   802         return false;

   803 

   804     unsigned long uoffset = static_cast<unsigned long>(offset);

   805     unsigned long n = count;

   806 

   807     if (type == GraphicsContext3D::UNSIGNED_SHORT) {

   808         // Make uoffset an element offset.

   809         uoffset /= 2;

   810         const unsigned short* p = static_cast<const unsigned short*>(m_boundElementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

   811         while (n-- > 0) {

   812             if (*p > lastIndex)

   813                 lastIndex = *p;

   814             ++p;

   815         }

   816     } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

   817         const unsigned char* p = static_cast<const unsigned char*>(m_boundElementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

   818         while (n-- > 0) {

   819             if (*p > lastIndex)

   820                 lastIndex = *p;

   821             ++p;

   822         }

   823     }    

   824         

   825     // Then set the last index in the index array and make sure it is valid.

   826     numElementsRequired = lastIndex + 1;

   827     return numElementsRequired > 0;

   828 }

   829 

   830 bool WebGLRenderingContext::validateRenderingState(long numElementsRequired)

   831 {

   832     if (!m_currentProgram)

   833         return false;

   834 

   835     int numAttribStates = static_cast<int>(m_vertexAttribState.size());

   836 

   837     // Look in each enabled vertex attrib and check if they've been bound to a buffer.

   838     for (int i = 0; i < numAttribStates; ++i) {

   839         if (m_vertexAttribState[i].enabled

   840             && (!m_vertexAttribState[i].bufferBinding || !m_vertexAttribState[i].bufferBinding->object()))

   841             return false;

   842     }

   843 

   844     // Look in each consumed vertex attrib (by the current program) and find the smallest buffer size

   845     long smallestNumElements = LONG_MAX;

   846     int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();

   847     for (int i = 0; i < numActiveAttribLocations; ++i) {

   848         int loc = m_currentProgram->getActiveAttribLocation(i);

   849         if (loc >=0 && loc < numAttribStates) {

   850             const VertexAttribState& state = m_vertexAttribState[loc];

   851             if (state.enabled) {

   852                 // Avoid off-by-one errors in numElements computation.

   853                 // For the last element, we will only touch the data for the

   854                 // element and nothing beyond it.

   855                 long bytesRemaining = state.bufferBinding->byteLength() - state.offset;

   856                 long numElements = 0;

   857                 if (bytesRemaining >= state.bytesPerElement)

   858                     numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;

   859                 if (numElements < smallestNumElements)

   860                     smallestNumElements = numElements;

   861             }

   862         }

   863     }

   864     

   865     if (smallestNumElements == LONG_MAX)

   866         smallestNumElements = 0;

   867     

   868     return numElementsRequired <= smallestNumElements;

   869 }

   870 

   871 bool WebGLRenderingContext::validateWebGLObject(CanvasObject* object)

   872 {

   873     if (!object) {

   874         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   875         return false;

   876     }

   877     if (object->context() != this) {

   878         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   879         return false;

   880     }

   881     return true;

   882 }

   883 

   884 void WebGLRenderingContext::drawArrays(unsigned long mode, long first, long count, ExceptionCode& ec)

   885 {

   886     UNUSED_PARAM(ec);

   887 

   888     if (!validateDrawMode(mode))

   889         return;

   890 

   891     if (first < 0 || count < 0) {

   892         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   893         return;

   894     }

   895 

   896     // Ensure we have a valid rendering state

   897     CheckedInt<int32_t> checkedFirst(first);

   898     CheckedInt<int32_t> checkedCount(count);

   899     CheckedInt<int32_t> checkedSum = checkedFirst + checkedCount;

   900     if (!checkedSum.valid() || !validateRenderingState(checkedSum.value())) {

   901         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   902         return;

   903     }

   904 

   905     bool vertexAttrib0Simulated = false;

   906     if (!isGLES2Compliant()) {

   907         vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

   908         handleNPOTTextures(true);

   909     }

   910     m_context->drawArrays(mode, first, count);

   911     if (!isGLES2Compliant()) {

   912         handleNPOTTextures(false);

   913         if (vertexAttrib0Simulated)

   914             restoreStatesAfterVertexAttrib0Simulation();

   915     }

   916     cleanupAfterGraphicsCall(true);

   917 }

   918 

   919 void WebGLRenderingContext::drawElements(unsigned long mode, long count, unsigned long type, long offset, ExceptionCode& ec)

   920 {

   921     UNUSED_PARAM(ec);

   922 

   923     if (!validateDrawMode(mode))

   924         return;

   925 

   926     switch (type) {

   927     case GraphicsContext3D::UNSIGNED_BYTE:

   928     case GraphicsContext3D::UNSIGNED_SHORT:

   929         break;

   930     default:

   931         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

   932         return;

   933     }

   934 

   935     if (count < 0 || offset < 0) {

   936         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   937         return;

   938     }

   939 

   940     // Ensure we have a valid rendering state

   941     long numElements;

   942     

   943     if (!validateElementArraySize(count, type, offset)) {

   944         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   945         return;

   946     }

   947 

   948     if (!validateIndexArrayConservative(type, numElements) || !validateRenderingState(numElements))

   949         if (!validateIndexArrayPrecise(count, type, offset, numElements) || !validateRenderingState(numElements)) {

   950             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

   951             return;

   952         }

   953 

   954     bool vertexAttrib0Simulated = false;

   955     if (!isGLES2Compliant()) {

   956         vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

   957         handleNPOTTextures(true);

   958     }

   959     m_context->drawElements(mode, count, type, offset);

   960     if (!isGLES2Compliant()) {

   961         handleNPOTTextures(false);

   962         if (vertexAttrib0Simulated)

   963             restoreStatesAfterVertexAttrib0Simulation();

   964     }

   965     cleanupAfterGraphicsCall(true);

   966 }

   967 

   968 void WebGLRenderingContext::enable(unsigned long cap)

   969 {

   970     if (!isGLES2Compliant()) {

   971         if (!validateCapability(cap))

   972             return;

   973     }

   974     m_context->enable(cap);

   975     cleanupAfterGraphicsCall(false);

   976 }

   977 

   978 void WebGLRenderingContext::enableVertexAttribArray(unsigned long index, ExceptionCode& ec)

   979 {

   980     UNUSED_PARAM(ec);

   981     if (index >= m_maxVertexAttribs) {

   982         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

   983         return;

   984     }

   985     

   986     if (index >= m_vertexAttribState.size())

   987         m_vertexAttribState.resize(index + 1);

   988         

   989     m_vertexAttribState[index].enabled = true;

   990     

   991     m_context->enableVertexAttribArray(index);

   992     cleanupAfterGraphicsCall(false);

   993 }

   994 

   995 void WebGLRenderingContext::finish()

   996 {

   997     m_context->finish();

   998     cleanupAfterGraphicsCall(true);

   999 }

  1000 

  1001 

  1002 void WebGLRenderingContext::flush()

  1003 {

  1004     m_context->flush();

  1005     cleanupAfterGraphicsCall(true);

  1006 }

  1007 

  1008 void WebGLRenderingContext::framebufferRenderbuffer(unsigned long target, unsigned long attachment, unsigned long renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode& ec)

  1009 {

  1010     UNUSED_PARAM(ec);

  1011     if (!validateFramebufferFuncParameters(target, attachment))

  1012         return;

  1013     if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {

  1014         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

  1015         return;

  1016     }

  1017     if (buffer && buffer->context() != this) {

  1018         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1019         return;

  1020     }

  1021     // Don't allow the default framebuffer to be mutated; all current

  1022     // implementations use an FBO internally in place of the default

  1023     // FBO.

  1024     if (!m_framebufferBinding || !m_framebufferBinding->object()) {

  1025         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1026         return;

  1027     }

  1028     if (buffer && buffer->object()) {

  1029         bool isConflicted = false;

  1030         switch (attachment) {

  1031         case GraphicsContext3D::DEPTH_ATTACHMENT:

  1032             if (m_framebufferBinding->isDepthStencilAttached() || m_framebufferBinding->isStencilAttached())

  1033                 isConflicted = true;

  1034             if (buffer->getInternalFormat() != GraphicsContext3D::DEPTH_COMPONENT16)

  1035                 isConflicted = true;

  1036             break;

  1037         case GraphicsContext3D::STENCIL_ATTACHMENT:

  1038             if (m_framebufferBinding->isDepthStencilAttached() || m_framebufferBinding->isDepthAttached())

  1039                 isConflicted = true;

  1040             if (buffer->getInternalFormat() != GraphicsContext3D::STENCIL_INDEX8)

  1041                 isConflicted = true;

  1042             break;

  1043         case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

  1044             if (m_framebufferBinding->isDepthAttached() || m_framebufferBinding->isStencilAttached())

  1045                 isConflicted = true;

  1046             if (buffer->getInternalFormat() != GraphicsContext3D::DEPTH_STENCIL)

  1047                 isConflicted = true;

  1048             break;

  1049         }

  1050         if (isConflicted) {

  1051             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1052             return;

  1053         }

  1054     }

  1055     m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, buffer);

  1056     m_framebufferBinding->setAttachment(attachment, buffer);

  1057     cleanupAfterGraphicsCall(false);

  1058 }

  1059 

  1060 void WebGLRenderingContext::framebufferTexture2D(unsigned long target, unsigned long attachment, unsigned long textarget, WebGLTexture* texture, long level, ExceptionCode& ec)

  1061 {

  1062     UNUSED_PARAM(ec);

  1063     if (!validateFramebufferFuncParameters(target, attachment))

  1064         return;

  1065     if (level) {

  1066         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

  1067         return;

  1068     }

  1069     if (texture && texture->context() != this) {

  1070         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1071         return;

  1072     }

  1073     // Don't allow the default framebuffer to be mutated; all current

  1074     // implementations use an FBO internally in place of the default

  1075     // FBO.

  1076     if (!m_framebufferBinding || !m_framebufferBinding->object()) {

  1077         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1078         return;

  1079     }

  1080     m_context->framebufferTexture2D(target, attachment, textarget, texture, level);

  1081     m_framebufferBinding->setAttachment(attachment, texture);

  1082     cleanupAfterGraphicsCall(false);

  1083 }

  1084 

  1085 void WebGLRenderingContext::frontFace(unsigned long mode)

  1086 {

  1087     m_context->frontFace(mode);

  1088     cleanupAfterGraphicsCall(false);

  1089 }

  1090 

  1091 void WebGLRenderingContext::generateMipmap(unsigned long target)

  1092 {

  1093     RefPtr<WebGLTexture> tex;

  1094     if (!isGLES2Compliant()) {

  1095         if (target == GraphicsContext3D::TEXTURE_2D)

  1096             tex = m_textureUnits[m_activeTextureUnit].m_texture2DBinding;

  1097         else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP)

  1098             tex = m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding;

  1099         if (tex && !tex->canGenerateMipmaps()) {

  1100             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

  1101             return;

  1102         }

  1103     }

  1104     m_context->generateMipmap(target);

  1105     if (!isGLES2Compliant()) {

  1106         if (tex)

  1107             tex->generateMipmapLevelInfo();

  1108     }

  1109     cleanupAfterGraphicsCall(false);

  1110 }

  1111 

  1112 PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveAttrib(WebGLProgram* program, unsigned long index, ExceptionCode& ec)

  1113 {

  1114     UNUSED_PARAM(ec);

  1115     ActiveInfo info;

  1116     if (!validateWebGLObject(program))

  1117         return 0;

  1118     if (!m_context->getActiveAttrib(program, index, info)) {

  1119         return 0;

  1120     }

  1121     return WebGLActiveInfo::create(info.name, info.type, info.size);

  1122 }

  1123 

  1124 PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveUniform(WebGLProgram* program, unsigned long index, ExceptionCode& ec)

  1125 {

  1126     UNUSED_PARAM(ec);

  1127     ActiveInfo info;

  1128     if (!validateWebGLObject(program))

  1129         return 0;

  1130     if (!m_context->getActiveUniform(program, index, info)) {

  1131         return 0;

  1132     }

  1133     if (!isGLES2Compliant()) {

  1134         if (info.size > 1 && !info.name.endsWith("[0]"))

  1135             info.name.append("[0]");