Changeset 208032 in webkit


Ignore:
Timestamp:
Oct 27, 2016 10:28:55 PM (7 years ago)
Author:
mmaxfield@apple.com
Message:

Teach WebGL code about new buffer targets in WebGL2
​https://bugs.webkit.org/show_bug.cgi?id=163924

Reviewed by Dean Jackson.

Source/WebCore:

WebGL 2 adds new buffer targets. Instead of completely reimplementing
the functions again for WebGL 2, we can simply check if we are using
a new kind of context to conditionally enable support.

Test: fast/canvas/webgl/webgl2-buffer-targets.html

  • html/canvas/WebGL2RenderingContext.h:
  • html/canvas/WebGL2RenderingContext.idl:
  • html/canvas/WebGLBuffer.cpp:

(WebCore::WebGLBuffer::associateBufferDataImpl):
(WebCore::WebGLBuffer::associateBufferSubDataImpl):
(WebCore::WebGLBuffer::setTarget):

  • html/canvas/WebGLBuffer.h:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::bindBuffer):
(WebCore::WebGLRenderingContextBase::getBufferParameter):
(WebCore::WebGLRenderingContextBase::validateBufferDataParameters):

  • html/canvas/WebGLRenderingContextBase.h:

LayoutTests:

  • fast/canvas/webgl/bufferData-offset-length.html:
  • fast/canvas/webgl/webgl2-buffer-targets-expected.txt: Added.
  • fast/canvas/webgl/webgl2-buffer-targets.html: Added.
Location:
trunk
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r208025 r208032  
     12016-10-27  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Teach WebGL code about new buffer targets in WebGL2
     4        https://bugs.webkit.org/show_bug.cgi?id=163924
     5
     6        Reviewed by Dean Jackson.
     7
     8        * fast/canvas/webgl/bufferData-offset-length.html:
     9        * fast/canvas/webgl/webgl2-buffer-targets-expected.txt: Added.
     10        * fast/canvas/webgl/webgl2-buffer-targets.html: Added.
     11
    1122016-10-27  Simon Fraser  <simon.fraser@apple.com>
    213

  • trunk/LayoutTests/fast/canvas/webgl/bufferData-offset-length.html

    r207649 r208032  
    4040
    4141    if (window.internals)
    42                 internals.setWebGL2Enabled(true);
     42        internals.setWebGL2Enabled(true);
    4343    gl = initWebGL("example", "vshader", "fshader", [ "vPosition", "index" ],
    4444                   [ 1, 1, 1, 1 ], 1, null, true);
    … …  
    8181    checkRedValue(30, 10, 255, "Right half of canvas should be empty");
    8282
     83    gl.deleteBuffer(vertexObject);
     84
    8385    function checkRedValue(x, y, value, msg) {
    8486        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

  • trunk/Source/WebCore/ChangeLog

    r208031 r208032  
     12016-10-27  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Teach WebGL code about new buffer targets in WebGL2
     4        https://bugs.webkit.org/show_bug.cgi?id=163924
     5
     6        Reviewed by Dean Jackson.
     7
     8        WebGL 2 adds new buffer targets. Instead of completely reimplementing
     9        the functions again for WebGL 2, we can simply check if we are using
     10        a new kind of context to conditionally enable support.
     11
     12        Test: fast/canvas/webgl/webgl2-buffer-targets.html
     13
     14        * html/canvas/WebGL2RenderingContext.h:
     15        * html/canvas/WebGL2RenderingContext.idl:
     16        * html/canvas/WebGLBuffer.cpp:
     17        (WebCore::WebGLBuffer::associateBufferDataImpl):
     18        (WebCore::WebGLBuffer::associateBufferSubDataImpl):
     19        (WebCore::WebGLBuffer::setTarget):
     20        * html/canvas/WebGLBuffer.h:
     21        * html/canvas/WebGLRenderingContextBase.cpp:
     22        (WebCore::WebGLRenderingContextBase::bindBuffer):
     23        (WebCore::WebGLRenderingContextBase::getBufferParameter):
     24        (WebCore::WebGLRenderingContextBase::validateBufferDataParameters):
     25        * html/canvas/WebGLRenderingContextBase.h:
     26
    1272016-10-27  Dave Hyatt  <hyatt@apple.com>
    228

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h

    r207724 r208032  
    4545
    4646    /* Buffer objects */
     47    using WebGLRenderingContextBase::bufferData;
     48    using WebGLRenderingContextBase::bufferSubData;
    4749    void bufferData(GC3Denum target, ArrayBufferView& data, GC3Denum usage, GC3Duint srcOffset, GC3Duint length);
    4850    void bufferSubData(GC3Denum target, long long offset, ArrayBufferView& data, GC3Duint srcOffset, GC3Duint length);

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.idl

    r207685 r208032  
    4040typedef unrestricted float GLfloat;
    4141typedef unrestricted float GLclampf;
     42typedef (ArrayBuffer or ArrayBufferView) BufferDataSource;
    4243
    4344// FIXME: Should allow ImageBitmap too.
    … …  
    337338
    338339    /* Buffer objects */
     340    // WebGL1:
     341    void bufferData(GLenum target, GLsizeiptr size, GLenum usage);
     342    void bufferData(GLenum target, BufferDataSource? srcData, GLenum usage);
     343    void bufferSubData(GLenum target, GLintptr dstByteOffset, BufferDataSource? srcData);
     344    // WebGL2:
    339345    void bufferData(GLenum target, ArrayBufferView data, GLenum usage, GLuint srcOffset, optional GLuint length = 0);
    340346    void bufferSubData(GLenum target, GLintptr dstByteOffset, ArrayBufferView srcData, GLuint srcOffset, optional GLuint length = 0);
     347
    341348    void copyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
    342349    // MapBufferRange, in particular its read-only and write-only modes,

  • trunk/Source/WebCore/html/canvas/WebGLBuffer.cpp

    r208022 r208032  
    8888        return true;
    8989    default:
     90#if ENABLE(WEBGL2)
     91        switch (m_target) {
     92        case GraphicsContext3D::COPY_READ_BUFFER:
     93        case GraphicsContext3D::COPY_WRITE_BUFFER:
     94        case GraphicsContext3D::PIXEL_PACK_BUFFER:
     95        case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     96        case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     97        case GraphicsContext3D::UNIFORM_BUFFER:
     98            m_byteLength = byteLength;
     99            return true;
     100        }
     101#endif
    90102        return false;
    91103    }
    … …  
    136148        return true;
    137149    default:
     150#if ENABLE(WEBGL2)
     151        switch (m_target) {
     152        case GraphicsContext3D::COPY_READ_BUFFER:
     153        case GraphicsContext3D::COPY_WRITE_BUFFER:
     154        case GraphicsContext3D::PIXEL_PACK_BUFFER:
     155        case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     156        case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     157        case GraphicsContext3D::UNIFORM_BUFFER:
     158            return true;
     159        }
     160#endif
    138161        return false;
    139162    }
    … …  
    187210}
    188211
    189 void WebGLBuffer::setTarget(GC3Denum target)
     212void WebGLBuffer::setTarget(GC3Denum target, bool forWebGL2)
    190213{
    191214    // In WebGL, a buffer is bound to one target in its lifetime
    … …  
    194217    if (target == GraphicsContext3D::ARRAY_BUFFER || target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)
    195218        m_target = target;
     219    else if (forWebGL2) {
     220#if ENABLE(WEBGL2)
     221        switch (target) {
     222        case GraphicsContext3D::COPY_READ_BUFFER:
     223        case GraphicsContext3D::COPY_WRITE_BUFFER:
     224        case GraphicsContext3D::PIXEL_PACK_BUFFER:
     225        case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     226        case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     227        case GraphicsContext3D::UNIFORM_BUFFER:
     228            m_target = target;
     229        }
     230#endif
     231    }
    196232}
    197233

  • trunk/Source/WebCore/html/canvas/WebGLBuffer.h

    r197563 r208032  
    6262
    6363    GC3Denum getTarget() const { return m_target; }
    64     void setTarget(GC3Denum);
     64    void setTarget(GC3Denum, bool forWebGL2);
    6565
    6666    bool hasEverBeenBound() const { return object() && m_target; }

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r208022 r208032  
    920920        m_boundVertexArrayObject->setElementArrayBuffer(buffer);
    921921    else {
    922         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");
    923         return;
     922        bool success = false;
     923#if ENABLE(WEBGL2)
     924        if (isWebGL2()) {
     925            success = true;
     926            switch (target) {
     927            case GraphicsContext3D::COPY_READ_BUFFER:
     928                m_boundCopyReadBuffer = buffer;
     929                break;
     930            case GraphicsContext3D::COPY_WRITE_BUFFER:
     931                m_boundCopyWriteBuffer = buffer;
     932                break;
     933            case GraphicsContext3D::PIXEL_PACK_BUFFER:
     934                m_boundPixelPackBuffer = buffer;
     935                break;
     936            case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     937                m_boundPixelUnpackBuffer = buffer;
     938                break;
     939            case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     940                m_boundTransformFeedbackBuffer = buffer;
     941                break;
     942            case GraphicsContext3D::UNIFORM_BUFFER:
     943                m_boundUniformBuffer = buffer;
     944                break;
     945            default:
     946                success = false;
     947                break;
     948            }
     949        }
     950#endif
     951        if (!success) {
     952            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");
     953            return;
     954        }
    924955    }
    925956
    926957    m_context->bindBuffer(target, objectOrZero(buffer));
    927958    if (buffer)
    928         buffer->setTarget(target);
     959        buffer->setTarget(target, isWebGL2());
    929960}
    930961
    … …  
    21662197    if (isContextLostOrPending())
    21672198        return WebGLGetInfo();
    2168     if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {
     2199
     2200    bool valid = false;
     2201    if (target == GraphicsContext3D::ARRAY_BUFFER || target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)
     2202        valid = true;
     2203#if ENABLE(WEBGL2)
     2204    if (isWebGL2()) {
     2205        switch (target) {
     2206        case GraphicsContext3D::COPY_READ_BUFFER:
     2207        case GraphicsContext3D::COPY_WRITE_BUFFER:
     2208        case GraphicsContext3D::PIXEL_PACK_BUFFER:
     2209        case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     2210        case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     2211        case GraphicsContext3D::UNIFORM_BUFFER:
     2212            valid = true;
     2213        }
     2214    }
     2215#endif
     2216    if (!valid) {
    21692217        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");
    21702218        return WebGLGetInfo();
    … …  
    44584506        break;
    44594507    default:
     4508#if ENABLE(WEBGL2)
     4509        bool success = true;
     4510        if (isWebGL2()) {
     4511            switch (target) {
     4512            case GraphicsContext3D::COPY_READ_BUFFER:
     4513                buffer = m_boundCopyReadBuffer.get();
     4514                break;
     4515            case GraphicsContext3D::COPY_WRITE_BUFFER:
     4516                buffer = m_boundCopyWriteBuffer.get();
     4517                break;
     4518            case GraphicsContext3D::PIXEL_PACK_BUFFER:
     4519                buffer = m_boundPixelPackBuffer.get();
     4520                break;
     4521            case GraphicsContext3D::PIXEL_UNPACK_BUFFER:
     4522                buffer = m_boundPixelUnpackBuffer.get();
     4523                break;
     4524            case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER:
     4525                buffer = m_boundTransformFeedbackBuffer.get();
     4526                break;
     4527            case GraphicsContext3D::UNIFORM_BUFFER:
     4528                buffer = m_boundUniformBuffer.get();
     4529                break;
     4530            default:
     4531                success = false;
     4532                break;
     4533            }
     4534        } else
     4535            success = false;
     4536        if (success)
     4537            break;
     4538#endif
    44604539        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");
    44614540        return nullptr;

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.h

    r207724 r208032  
    428428    // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
    429429    RefPtr<WebGLBuffer> m_boundArrayBuffer;
     430    RefPtr<WebGLBuffer> m_boundCopyReadBuffer;
     431    RefPtr<WebGLBuffer> m_boundCopyWriteBuffer;
     432    RefPtr<WebGLBuffer> m_boundPixelPackBuffer;
     433    RefPtr<WebGLBuffer> m_boundPixelUnpackBuffer;
     434    RefPtr<WebGLBuffer> m_boundTransformFeedbackBuffer;
     435    RefPtr<WebGLBuffer> m_boundUniformBuffer;
    430436
    431437    RefPtr<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
Note: See TracChangeset for help on using the changeset viewer.