WebGL 2: add readPixels API to read pixels into pixel pack buffer

Source/modules/webgl/WebGLRenderingContextBase.idl

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 580 matching lines @@
     GLboolean isProgram(WebGLProgram? program);
     GLboolean isRenderbuffer(WebGLRenderbuffer? renderbuffer);
     GLboolean isShader(WebGLShader? shader);
     GLboolean isTexture(WebGLTexture? texture);
     void lineWidth(GLfloat width);
     void linkProgram(WebGLProgram? program);
     void pixelStorei(GLenum pname, GLint param);
     void polygonOffset(GLfloat factor, GLfloat units);
 
     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView? pixels);
+    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLintptr offset);

[Zhenyao Mo, 2015/08/17 17:02:47]

No, you can't expose this to WebGL 1.  It is a WebGL 2 only function.

[yunchao, 2015/08/18 02:30:00]

In the implementation, we can directly return and do nothing under WebGL 1
rendering context. So this API will not be exposed to the web developers. WDYT? 

Another solution is that we can use the [Custom] tag in the IDL file, and
manually write the binding code under WebKit/Source/bindings/core/v8/custom/. 

Final solution I can imagine: 
1. create a new attribute, say [CrossClassOverload], in IDL file. 
2. write python code to generate appropriate js binding code to support
cross-class overloading, although cross-class overloading is not syntactically
correct in C++. 

Any comments? Maybe I am wrong... 

[Ken Russell (switch to Gerrit), 2015/08/18 02:55:48]

I'm not sure that this would be completely invisible to JavaScript.
Why is this necessary?
Why can this not just be added to WebGL2RenderingContextBase.idl? Is there a
deficiency in the code generator?
What is the issue with cross-class overloading? WebGLRenderingContextBase.h
would define one overloading of readPixels and WebGL2RenderingContextBase.h
would define the other overload.

[yunchao, 2015/08/18 05:35:58]

cross-class overloading is not allowed, it will always call the function in the
sub-class, making the JS binding code failed (parameter mismatch:
'DOMArrayBufferView' to 'long long' in this case). 

Well, we can make the original WebGLRenderingContextBase::readPixels virtual,
and override it in WebGL2RenderingContext. then
WebGL2RenderingContext::readPixels(,,,, DOMArrayBufferView* pixels ) can
correctly overloads with WebGL2RenderingContext(,,,,, long long offset), because
these two readPixels are in the same class (WebGL2RenderingContext) now.

Code has been updated, PTAL when you have time.

 
     void renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
     void sampleCoverage(GLclampf value, GLboolean invert);
     void scissor(GLint x, GLint y, GLsizei width, GLsizei height);
     void shaderSource(WebGLShader? shader, DOMString string);
     void stencilFunc(GLenum func, GLint ref, GLuint mask);
     void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
     void stencilMask(GLuint mask);
     void stencilMaskSeparate(GLenum face, GLuint mask);
     void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);
@@ skipping 84 matching lines @@
     void vertexAttrib3fv(GLuint indx, Float32Array values);
     void vertexAttrib3fv(GLuint indx, sequence<GLfloat> values);
     void vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
     void vertexAttrib4fv(GLuint indx, Float32Array values);
     void vertexAttrib4fv(GLuint indx, sequence<GLfloat> values);
     void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized,
                              GLsizei stride, GLintptr offset);
 
     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
 };