Diff
Modified: trunk/Source/WebCore/ChangeLog (179141 => 179142)
--- trunk/Source/WebCore/ChangeLog 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/ChangeLog 2015-01-26 22:03:00 UTC (rev 179142)
@@ -1,3 +1,116 @@
+2015-01-26 Roger Fong <roger_f...@apple.com>
+
+ [WebGL2] Update IDL for WebGL2.
+ https://bugs.webkit.org/show_bug.cgi?id=126406
+ <rdar://problem/15002268>.
+
+ Reviewed by Brent Fulgham.
+
+ Update WebGL2RenderingContext idl to match spec. Create method stubs as necessary.
+
+ * bindings/js/JSWebGL2RenderingContextCustom.cpp:
+ (WebCore::JSWebGL2RenderingContext::getFramebufferAttachmentParameter):
+ (WebCore::JSWebGL2RenderingContext::getInternalformatParameter):
+ (WebCore::JSWebGL2RenderingContext::getQueryParameter):
+ (WebCore::JSWebGL2RenderingContext::getSamplerParameter):
+ (WebCore::JSWebGL2RenderingContext::getSyncParameter):
+ (WebCore::JSWebGL2RenderingContext::getIndexedParameter):
+ (WebCore::JSWebGL2RenderingContext::getActiveUniformBlockParameter):
+ (WebCore::JSWebGL2RenderingContext::getActiveUniformBlockName):
+ * html/canvas/WebGL2RenderingContext.cpp:
+ (WebCore::WebGL2RenderingContext::copyBufferSubData):
+ (WebCore::WebGL2RenderingContext::getBufferSubData):
+ (WebCore::WebGL2RenderingContext::getFramebufferAttachmentParameter):
+ (WebCore::WebGL2RenderingContext::blitFramebuffer):
+ (WebCore::WebGL2RenderingContext::framebufferTextureLayer):
+ (WebCore::WebGL2RenderingContext::getInternalformatParameter):
+ (WebCore::WebGL2RenderingContext::invalidateFramebuffer):
+ (WebCore::WebGL2RenderingContext::invalidateSubFramebuffer):
+ (WebCore::WebGL2RenderingContext::readBuffer):
+ (WebCore::WebGL2RenderingContext::renderbufferStorageMultisample):
+ (WebCore::WebGL2RenderingContext::texStorage2D):
+ (WebCore::WebGL2RenderingContext::texStorage3D):
+ (WebCore::WebGL2RenderingContext::texImage3D):
+ (WebCore::WebGL2RenderingContext::texSubImage3D):
+ (WebCore::WebGL2RenderingContext::copyTexSubImage3D):
+ (WebCore::WebGL2RenderingContext::compressedTexImage3D):
+ (WebCore::WebGL2RenderingContext::compressedTexSubImage3D):
+ (WebCore::WebGL2RenderingContext::getFragDataLocation):
+ (WebCore::WebGL2RenderingContext::uniform1ui):
+ (WebCore::WebGL2RenderingContext::uniform2ui):
+ (WebCore::WebGL2RenderingContext::uniform3ui):
+ (WebCore::WebGL2RenderingContext::uniform4ui):
+ (WebCore::WebGL2RenderingContext::uniform1uiv):
+ (WebCore::WebGL2RenderingContext::uniform2uiv):
+ (WebCore::WebGL2RenderingContext::uniform3uiv):
+ (WebCore::WebGL2RenderingContext::uniform4uiv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix2x3fv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix3x2fv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix2x4fv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix4x2fv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix3x4fv):
+ (WebCore::WebGL2RenderingContext::uniformMatrix4x3fv):
+ (WebCore::WebGL2RenderingContext::vertexAttribI4i):
+ (WebCore::WebGL2RenderingContext::vertexAttribI4iv):
+ (WebCore::WebGL2RenderingContext::vertexAttribI4ui):
+ (WebCore::WebGL2RenderingContext::vertexAttribI4uiv):
+ (WebCore::WebGL2RenderingContext::vertexAttribIPointer):
+ (WebCore::WebGL2RenderingContext::vertexAttribDivisor):
+ (WebCore::WebGL2RenderingContext::drawArraysInstanced):
+ (WebCore::WebGL2RenderingContext::drawElementsInstanced):
+ (WebCore::WebGL2RenderingContext::drawRangeElements):
+ (WebCore::WebGL2RenderingContext::drawBuffers):
+ (WebCore::WebGL2RenderingContext::clearBufferiv):
+ (WebCore::WebGL2RenderingContext::clearBufferuiv):
+ (WebCore::WebGL2RenderingContext::clearBufferfv):
+ (WebCore::WebGL2RenderingContext::clearBufferfi):
+ (WebCore::WebGL2RenderingContext::createQuery):
+ (WebCore::WebGL2RenderingContext::deleteQuery):
+ (WebCore::WebGL2RenderingContext::isQuery):
+ (WebCore::WebGL2RenderingContext::beginQuery):
+ (WebCore::WebGL2RenderingContext::endQuery):
+ (WebCore::WebGL2RenderingContext::getQuery):
+ (WebCore::WebGL2RenderingContext::getQueryParameter):
+ (WebCore::WebGL2RenderingContext::createSampler):
+ (WebCore::WebGL2RenderingContext::deleteSampler):
+ (WebCore::WebGL2RenderingContext::isSampler):
+ (WebCore::WebGL2RenderingContext::bindSampler):
+ (WebCore::WebGL2RenderingContext::samplerParameteri):
+ (WebCore::WebGL2RenderingContext::samplerParameterf):
+ (WebCore::WebGL2RenderingContext::getSamplerParameter):
+ (WebCore::WebGL2RenderingContext::fenceSync):
+ (WebCore::WebGL2RenderingContext::isSync):
+ (WebCore::WebGL2RenderingContext::deleteSync):
+ (WebCore::WebGL2RenderingContext::clientWaitSync):
+ (WebCore::WebGL2RenderingContext::waitSync):
+ (WebCore::WebGL2RenderingContext::getSyncParameter):
+ (WebCore::WebGL2RenderingContext::createTransformFeedback):
+ (WebCore::WebGL2RenderingContext::deleteTransformFeedback):
+ (WebCore::WebGL2RenderingContext::isTransformFeedback):
+ (WebCore::WebGL2RenderingContext::bindTransformFeedback):
+ (WebCore::WebGL2RenderingContext::beginTransformFeedback):
+ (WebCore::WebGL2RenderingContext::endTransformFeedback):
+ (WebCore::WebGL2RenderingContext::transformFeedbackVaryings):
+ (WebCore::WebGL2RenderingContext::getTransformFeedbackVarying):
+ (WebCore::WebGL2RenderingContext::pauseTransformFeedback):
+ (WebCore::WebGL2RenderingContext::resumeTransformFeedback):
+ (WebCore::WebGL2RenderingContext::bindBufferBase):
+ (WebCore::WebGL2RenderingContext::bindBufferRange):
+ (WebCore::WebGL2RenderingContext::getIndexedParameter):
+ (WebCore::WebGL2RenderingContext::getUniformIndices):
+ (WebCore::WebGL2RenderingContext::getActiveUniforms):
+ (WebCore::WebGL2RenderingContext::getUniformBlockIndex):
+ (WebCore::WebGL2RenderingContext::getActiveUniformBlockParameter):
+ (WebCore::WebGL2RenderingContext::getActiveUniformBlockName):
+ (WebCore::WebGL2RenderingContext::uniformBlockBinding):
+ (WebCore::WebGL2RenderingContext::createVertexArray):
+ (WebCore::WebGL2RenderingContext::deleteVertexArray):
+ (WebCore::WebGL2RenderingContext::isVertexArray):
+ (WebCore::WebGL2RenderingContext::bindVertexArray):
+ * html/canvas/WebGL2RenderingContext.h:
+ * html/canvas/WebGL2RenderingContext.idl:
+ * platform/graphics/GraphicsTypes3D.h:
+
2015-01-26 Andreas Kling <akl...@apple.com>
Don't let the CSSValuePool's font family cache grow unbounded.
Modified: trunk/Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp (179141 => 179142)
--- trunk/Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp 2015-01-26 22:03:00 UTC (rev 179142)
@@ -36,7 +36,56 @@
{
visitor.addOpaqueRoot(&impl());
}
+
+JSValue JSWebGL2RenderingContext::getFramebufferAttachmentParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+JSValue JSWebGL2RenderingContext::getInternalformatParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getQueryParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getSamplerParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getSyncParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getIndexedParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getActiveUniformBlockParameter(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+JSValue JSWebGL2RenderingContext::getActiveUniformBlockName(ExecState* exec)
+{
+ UNUSED_PARAM(exec);
+ return jsUndefined();
+}
+
+
} // namespace WebCore
#endif // ENABLE(WEBGL)
Modified: trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp (179141 => 179142)
--- trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp 2015-01-26 22:03:00 UTC (rev 179142)
@@ -28,6 +28,13 @@
#if ENABLE(WEBGL)
#include "WebGL2RenderingContext.h"
+#include "WebGLActiveInfo.h"
+#include "WebGLQuery.h"
+#include "WebGLSampler.h"
+#include "WebGLSync.h"
+#include "WebGLTransformFeedback.h"
+#include "WebGLVertexArrayObject.h"
+
namespace WebCore {
WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
@@ -39,6 +46,711 @@
GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, context, attributes)
{
}
+
+void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size)
+{
+ UNUSED_PARAM(readTarget);
+ UNUSED_PARAM(writeTarget);
+ UNUSED_PARAM(readOffset);
+ UNUSED_PARAM(writeOffset);
+ UNUSED_PARAM(size);
+}
+
+void WebGL2RenderingContext::getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBufferView* returnedData)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(offset);
+ UNUSED_PARAM(returnedData);
+}
+
+void WebGL2RenderingContext::getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBuffer* returnedData)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(offset);
+ UNUSED_PARAM(returnedData);
+}
+
+WebGLGetInfo WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(attachment);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+void WebGL2RenderingContext::blitFramebuffer(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter)
+{
+ UNUSED_PARAM(srcX0);
+ UNUSED_PARAM(srcX1);
+ UNUSED_PARAM(srcY0);
+ UNUSED_PARAM(srcY1);
+ UNUSED_PARAM(dstX0);
+ UNUSED_PARAM(dstX1);
+ UNUSED_PARAM(dstY0);
+ UNUSED_PARAM(dstY1);
+ UNUSED_PARAM(mask);
+ UNUSED_PARAM(filter);
+}
+
+void WebGL2RenderingContext::framebufferTextureLayer(GC3Denum target, GC3Denum attachment, GC3Duint texture, GC3Dint level, GC3Dint layer)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(attachment);
+ UNUSED_PARAM(texture);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(layer);
+}
+
+WebGLGetInfo WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+void WebGL2RenderingContext::invalidateFramebuffer(GC3Denum target, Vector<GC3Denum> attachments)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(attachments);
+}
+
+void WebGL2RenderingContext::invalidateSubFramebuffer(GC3Denum target, Vector<GC3Denum> attachments, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(attachments);
+ UNUSED_PARAM(x);
+ UNUSED_PARAM(y);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+}
+
+void WebGL2RenderingContext::readBuffer(GC3Denum src)
+{
+ UNUSED_PARAM(src);
+}
+
+void WebGL2RenderingContext::renderbufferStorageMultisample(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(samples);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+}
+
+void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(levels);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+}
+
+void WebGL2RenderingContext::texStorage3D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(levels);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+ UNUSED_PARAM(depth);
+}
+
+void WebGL2RenderingContext::texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, ArrayBufferView* pixels)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+ UNUSED_PARAM(depth);
+ UNUSED_PARAM(border);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(pixels);
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, ArrayBufferView* pixels)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+ UNUSED_PARAM(depth);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(pixels);
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, ImageData* source)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(source);
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLImageElement* source)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(source);
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* source)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(source);
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* source)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(source);
+}
+
+void WebGL2RenderingContext::copyTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(x);
+ UNUSED_PARAM(y);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+}
+
+void WebGL2RenderingContext::compressedTexImage3D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Dsizei imageSize, ArrayBufferView* data)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(internalformat);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+ UNUSED_PARAM(depth);
+ UNUSED_PARAM(border);
+ UNUSED_PARAM(imageSize);
+ UNUSED_PARAM(data);
+}
+
+void WebGL2RenderingContext::compressedTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Dsizei imageSize, ArrayBufferView* data)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(level);
+ UNUSED_PARAM(xoffset);
+ UNUSED_PARAM(yoffset);
+ UNUSED_PARAM(zoffset);
+ UNUSED_PARAM(width);
+ UNUSED_PARAM(height);
+ UNUSED_PARAM(depth);
+ UNUSED_PARAM(format);
+ UNUSED_PARAM(imageSize);
+ UNUSED_PARAM(data);
+}
+
+GC3Dint WebGL2RenderingContext::getFragDataLocation(WebGLProgram* program, String name)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(name);
+ return 0;
+}
+
+void WebGL2RenderingContext::uniform1ui(WebGLUniformLocation* location, GC3Duint v0)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(v0);
+}
+
+void WebGL2RenderingContext::uniform2ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(v0);
+ UNUSED_PARAM(v1);
+}
+
+void WebGL2RenderingContext::uniform3ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(v0);
+ UNUSED_PARAM(v1);
+ UNUSED_PARAM(v2);
+}
+
+void WebGL2RenderingContext::uniform4ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2, GC3Duint v3)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(v0);
+ UNUSED_PARAM(v1);
+ UNUSED_PARAM(v2);
+ UNUSED_PARAM(v3);
+}
+
+void WebGL2RenderingContext::uniform1uiv(WebGLUniformLocation* location, Uint32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniform2uiv(WebGLUniformLocation* location, Uint32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniform3uiv(WebGLUniformLocation* location, Uint32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniform4uiv(WebGLUniformLocation* location, Uint32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix2x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix3x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix2x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix4x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix3x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::uniformMatrix4x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
+{
+ UNUSED_PARAM(location);
+ UNUSED_PARAM(transpose);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::vertexAttribI4i(GC3Duint index, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(x);
+ UNUSED_PARAM(y);
+ UNUSED_PARAM(z);
+ UNUSED_PARAM(w);
+}
+
+void WebGL2RenderingContext::vertexAttribI4iv(GC3Duint index, Int32Array* v)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(v);
+}
+
+void WebGL2RenderingContext::vertexAttribI4ui(GC3Duint index, GC3Duint x, GC3Duint y, GC3Duint z, GC3Duint w)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(x);
+ UNUSED_PARAM(y);
+ UNUSED_PARAM(z);
+ UNUSED_PARAM(w);
+}
+
+void WebGL2RenderingContext::vertexAttribI4uiv(GC3Duint index, Uint32Array* v)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(v);
+}
+
+void WebGL2RenderingContext::vertexAttribIPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dsizei stride, GC3Dint64 offset)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(size);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(stride);
+ UNUSED_PARAM(offset);
+}
+
+
+void WebGL2RenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+{
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(divisor);
+}
+
+void WebGL2RenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount)
+{
+ UNUSED_PARAM(mode);
+ UNUSED_PARAM(first);
+ UNUSED_PARAM(count);
+ UNUSED_PARAM(instanceCount);
+}
+
+void WebGL2RenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount)
+{
+ UNUSED_PARAM(mode);
+ UNUSED_PARAM(count);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(offset);
+ UNUSED_PARAM(instanceCount);
+}
+
+void WebGL2RenderingContext::drawRangeElements(GC3Denum mode, GC3Duint start, GC3Duint end, GC3Dsizei count, GC3Denum type, GC3Dint64 offset)
+{
+ UNUSED_PARAM(mode);
+ UNUSED_PARAM(start);
+ UNUSED_PARAM(end);
+ UNUSED_PARAM(count);
+ UNUSED_PARAM(type);
+ UNUSED_PARAM(offset);
+}
+
+void WebGL2RenderingContext::drawBuffers(Vector<GC3Denum> buffers)
+{
+ UNUSED_PARAM(buffers);
+}
+
+void WebGL2RenderingContext::clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, Int32Array* value)
+{
+ UNUSED_PARAM(buffer);
+ UNUSED_PARAM(drawbuffer);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, Uint32Array* value)
+{
+ UNUSED_PARAM(buffer);
+ UNUSED_PARAM(drawbuffer);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, Float32Array* value)
+{
+ UNUSED_PARAM(buffer);
+ UNUSED_PARAM(drawbuffer);
+ UNUSED_PARAM(value);
+}
+
+void WebGL2RenderingContext::clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat depth, GC3Dint stencil)
+{
+ UNUSED_PARAM(buffer);
+ UNUSED_PARAM(drawbuffer);
+ UNUSED_PARAM(depth);
+ UNUSED_PARAM(stencil);
+}
+
+PassRefPtr<WebGLQuery> WebGL2RenderingContext::createQuery()
+{
+ return nullptr;
+}
+
+void WebGL2RenderingContext::deleteQuery(WebGLQuery* query)
+{
+ UNUSED_PARAM(query);
+}
+
+GC3Dboolean WebGL2RenderingContext::isQuery(WebGLQuery* query)
+{
+ UNUSED_PARAM(query);
+ return false;
+}
+
+void WebGL2RenderingContext::beginQuery(GC3Denum target, WebGLQuery* query)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(query);
+}
+
+void WebGL2RenderingContext::endQuery(GC3Denum target)
+{
+ UNUSED_PARAM(target);
+}
+
+PassRefPtr<WebGLQuery> WebGL2RenderingContext::getQuery(GC3Denum target, GC3Denum pname)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(pname);
+ return nullptr;
+}
+
+WebGLGetInfo WebGL2RenderingContext::getQueryParameter(WebGLQuery* query, GC3Denum pname)
+{
+ UNUSED_PARAM(query);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+PassRefPtr<WebGLSampler> WebGL2RenderingContext::createSampler()
+{
+ return nullptr;
+}
+
+void WebGL2RenderingContext::deleteSampler(WebGLSampler* sampler)
+{
+ UNUSED_PARAM(sampler);
+}
+
+GC3Dboolean WebGL2RenderingContext::isSampler(WebGLSampler* sampler)
+{
+ UNUSED_PARAM(sampler);
+ return false;
+}
+
+void WebGL2RenderingContext::bindSampler(GC3Duint unit, WebGLSampler* sampler)
+{
+ UNUSED_PARAM(unit);
+ UNUSED_PARAM(sampler);
+}
+
+void WebGL2RenderingContext::samplerParameteri(WebGLSampler* sampler, GC3Denum pname, GC3Dint param)
+{
+ UNUSED_PARAM(sampler);
+ UNUSED_PARAM(pname);
+ UNUSED_PARAM(param);
+}
+
+void WebGL2RenderingContext::samplerParameterf(WebGLSampler* sampler, GC3Denum pname, GC3Dfloat param)
+{
+ UNUSED_PARAM(sampler);
+ UNUSED_PARAM(pname);
+ UNUSED_PARAM(param);
+}
+
+WebGLGetInfo WebGL2RenderingContext::getSamplerParameter(WebGLSampler* sampler, GC3Denum pname)
+{
+ UNUSED_PARAM(sampler);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+PassRefPtr<WebGLSync> WebGL2RenderingContext::fenceSync(GC3Denum condition, GC3Dbitfield flags)
+{
+ UNUSED_PARAM(condition);
+ UNUSED_PARAM(flags);
+ return nullptr;
+}
+
+GC3Dboolean WebGL2RenderingContext::isSync(WebGLSync* sync)
+{
+ UNUSED_PARAM(sync);
+ return false;
+}
+
+void WebGL2RenderingContext::deleteSync(WebGLSync* sync)
+{
+ UNUSED_PARAM(sync);
+}
+
+GC3Denum WebGL2RenderingContext::clientWaitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout)
+{
+ UNUSED_PARAM(sync);
+ UNUSED_PARAM(flags);
+ UNUSED_PARAM(timeout);
+ return 0;
+}
+
+void WebGL2RenderingContext::waitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout)
+{
+ UNUSED_PARAM(sync);
+ UNUSED_PARAM(flags);
+ UNUSED_PARAM(timeout);
+}
+
+WebGLGetInfo WebGL2RenderingContext::getSyncParameter(WebGLSync* sync, GC3Denum pname)
+{
+ UNUSED_PARAM(sync);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+PassRefPtr<WebGLTransformFeedback> WebGL2RenderingContext::createTransformFeedback()
+{
+ return nullptr;
+}
+
+void WebGL2RenderingContext::deleteTransformFeedback(WebGLTransformFeedback* id)
+{
+ UNUSED_PARAM(id);
+}
+
+GC3Dboolean WebGL2RenderingContext::isTransformFeedback(WebGLTransformFeedback* id)
+{
+ UNUSED_PARAM(id);
+ return false;
+}
+
+void WebGL2RenderingContext::bindTransformFeedback(GC3Denum target, WebGLTransformFeedback* id)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(id);
+}
+
+void WebGL2RenderingContext::beginTransformFeedback(GC3Denum primitiveMode)
+{
+ UNUSED_PARAM(primitiveMode);
+}
+
+void WebGL2RenderingContext::endTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::transformFeedbackVaryings(WebGLProgram* program, Vector<String> varyings, GC3Denum bufferMode)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(varyings);
+ UNUSED_PARAM(bufferMode);
+}
+
+PassRefPtr<WebGLActiveInfo> WebGL2RenderingContext::getTransformFeedbackVarying(WebGLProgram* program, GC3Duint index)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(index);
+ return nullptr;
+}
+
+void WebGL2RenderingContext::pauseTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::resumeTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::bindBufferBase(GC3Denum target, GC3Duint index, WebGLBuffer* buffer)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(buffer);
+}
+
+void WebGL2RenderingContext::bindBufferRange(GC3Denum target, GC3Duint index, WebGLBuffer* buffer, GC3Dint64 offset, GC3Dint64 size)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(index);
+ UNUSED_PARAM(buffer);
+ UNUSED_PARAM(offset);
+ UNUSED_PARAM(size);
+}
+
+WebGLGetInfo WebGL2RenderingContext::getIndexedParameter(GC3Denum target, GC3Duint index)
+{
+ UNUSED_PARAM(target);
+ UNUSED_PARAM(index);
+ return WebGLGetInfo();
+}
+
+Uint32Array* WebGL2RenderingContext::getUniformIndices(WebGLProgram* program, Vector<String> uniformNames)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformNames);
+ return nullptr;
+}
+
+Int32Array* WebGL2RenderingContext::getActiveUniforms(WebGLProgram* program, Uint32Array* uniformIndices, GC3Denum pname)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformIndices);
+ UNUSED_PARAM(pname);
+ return nullptr;
+}
+
+GC3Duint WebGL2RenderingContext::getUniformBlockIndex(WebGLProgram* program, String uniformBlockName)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformBlockName);
+ return 0;
+}
+
+WebGLGetInfo WebGL2RenderingContext::getActiveUniformBlockParameter(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Denum pname)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformBlockIndex);
+ UNUSED_PARAM(pname);
+ return WebGLGetInfo();
+}
+
+WebGLGetInfo WebGL2RenderingContext::getActiveUniformBlockName(WebGLProgram* program, GC3Duint uniformBlockIndex)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformBlockIndex);
+ return WebGLGetInfo();
+}
+
+void WebGL2RenderingContext::uniformBlockBinding(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Duint uniformBlockBinding)
+{
+ UNUSED_PARAM(program);
+ UNUSED_PARAM(uniformBlockIndex);
+ UNUSED_PARAM(uniformBlockBinding);
+}
+
+PassRefPtr<WebGLVertexArrayObject> WebGL2RenderingContext::createVertexArray()
+{
+ return nullptr;
+}
+
+void WebGL2RenderingContext::deleteVertexArray(WebGLVertexArrayObject* vertexArray)
+{
+ UNUSED_PARAM(vertexArray);
+}
+
+GC3Dboolean WebGL2RenderingContext::isVertexArray(WebGLVertexArrayObject* vertexArray)
+{
+ UNUSED_PARAM(vertexArray);
+ return false;
+}
+
+void WebGL2RenderingContext::bindVertexArray(WebGLVertexArrayObject* vertexArray)
+{
+ UNUSED_PARAM(vertexArray);
+}
+
} // namespace WebCore
#endif // ENABLE(WEBGL)
Modified: trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h (179141 => 179142)
--- trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h 2015-01-26 22:03:00 UTC (rev 179142)
@@ -30,11 +30,139 @@
namespace WebCore {
+class WebGLQuery;
+class WebGLSampler;
+class WebGLSync;
+class WebGLTransformFeedback;
+class WebGLVertexArrayObject;
+
class WebGL2RenderingContext final : public WebGLRenderingContextBase {
public:
WebGL2RenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);
WebGL2RenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
virtual bool isWebGL2() const { return true; }
+
+ /* Buffer objects */
+ void copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size);
+ void getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBufferView* returnedData);
+ void getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBuffer* returnedData);
+
+ /* Framebuffer objects */
+ WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname);
+ void blitFramebuffer(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter);
+ void framebufferTextureLayer(GC3Denum target, GC3Denum attachment, GC3Duint texture, GC3Dint level, GC3Dint layer);
+ WebGLGetInfo getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname);
+ void invalidateFramebuffer(GC3Denum target, Vector<GC3Denum> attachments);
+ void invalidateSubFramebuffer(GC3Denum target, Vector<GC3Denum> attachments, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+ void readBuffer(GC3Denum src);
+
+ /* Renderbuffer objects */
+ void renderbufferStorageMultisample(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
+
+ /* Texture objects */
+ void texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
+ void texStorage3D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth);
+ void texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, ArrayBufferView* pixels);
+ void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, ArrayBufferView* pixels);
+ void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, ImageData* source);
+ void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLImageElement* source);
+ void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* source);
+ void texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* source);
+ void copyTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
+ void compressedTexImage3D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Dsizei imageSize, ArrayBufferView* data);
+ void compressedTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Dsizei imageSize, ArrayBufferView* data);
+
+ /* Programs and shaders */
+ GC3Dint getFragDataLocation(WebGLProgram* program, String name);
+
+ /* Uniforms and attributes */
+ void uniform1ui(WebGLUniformLocation* location, GC3Duint v0);
+ void uniform2ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1);
+ void uniform3ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2);
+ void uniform4ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2, GC3Duint v3);
+ void uniform1uiv(WebGLUniformLocation* location, Uint32Array* value);
+ void uniform2uiv(WebGLUniformLocation* location, Uint32Array* value);
+ void uniform3uiv(WebGLUniformLocation* location, Uint32Array* value);
+ void uniform4uiv(WebGLUniformLocation* location, Uint32Array* value);
+ void uniformMatrix2x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void uniformMatrix3x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void uniformMatrix2x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void uniformMatrix4x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void uniformMatrix3x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void uniformMatrix4x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value);
+ void vertexAttribI4i(GC3Duint index, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w);
+ void vertexAttribI4iv(GC3Duint index, Int32Array* v);
+ void vertexAttribI4ui(GC3Duint index, GC3Duint x, GC3Duint y, GC3Duint z, GC3Duint w);
+ void vertexAttribI4uiv(GC3Duint index, Uint32Array* v);
+ void vertexAttribIPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dsizei stride, GC3Dint64 offset);
+
+ /* Writing to the drawing buffer */
+ void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
+ void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount);
+ void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount);
+ void drawRangeElements(GC3Denum mode, GC3Duint start, GC3Duint end, GC3Dsizei count, GC3Denum type, GC3Dint64 offset);
+
+ /* Multiple Render Targets */
+ void drawBuffers(Vector<GC3Denum> buffers);
+ void clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, Int32Array* value);
+ void clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, Uint32Array* value);
+ void clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, Float32Array* value);
+ void clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat depth, GC3Dint stencil);
+
+ /* Query Objects */
+ PassRefPtr<WebGLQuery> createQuery();
+ void deleteQuery(WebGLQuery* query);
+ GC3Dboolean isQuery(WebGLQuery* query);
+ void beginQuery(GC3Denum target, WebGLQuery* query);
+ void endQuery(GC3Denum target);
+ PassRefPtr<WebGLQuery> getQuery(GC3Denum target, GC3Denum pname);
+ WebGLGetInfo getQueryParameter(WebGLQuery* query, GC3Denum pname);
+
+ /* Sampler Objects */
+ PassRefPtr<WebGLSampler> createSampler();
+ void deleteSampler(WebGLSampler* sampler);
+ GC3Dboolean isSampler(WebGLSampler* sampler);
+ void bindSampler(GC3Duint unit, WebGLSampler* sampler);
+ void samplerParameteri(WebGLSampler* sampler, GC3Denum pname, GC3Dint param);
+ void samplerParameterf(WebGLSampler* sampler, GC3Denum pname, GC3Dfloat param);
+ WebGLGetInfo getSamplerParameter(WebGLSampler* sampler, GC3Denum pname);
+
+ /* Sync objects */
+ PassRefPtr<WebGLSync> fenceSync(GC3Denum condition, GC3Dbitfield flags);
+ GC3Dboolean isSync(WebGLSync* sync);
+ void deleteSync(WebGLSync* sync);
+ GC3Denum clientWaitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout);
+ void waitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout);
+ WebGLGetInfo getSyncParameter(WebGLSync* sync, GC3Denum pname);
+
+ /* Transform Feedback */
+ PassRefPtr<WebGLTransformFeedback> createTransformFeedback();
+ void deleteTransformFeedback(WebGLTransformFeedback* id);
+ GC3Dboolean isTransformFeedback(WebGLTransformFeedback* id);
+ void bindTransformFeedback(GC3Denum target, WebGLTransformFeedback* id);
+ void beginTransformFeedback(GC3Denum primitiveMode);
+ void endTransformFeedback();
+ void transformFeedbackVaryings(WebGLProgram* program, Vector<String> varyings, GC3Denum bufferMode);
+ PassRefPtr<WebGLActiveInfo> getTransformFeedbackVarying(WebGLProgram* program, GC3Duint index);
+ void pauseTransformFeedback();
+ void resumeTransformFeedback();
+
+ /* Uniform Buffer Objects and Transform Feedback Buffers */
+ void bindBufferBase(GC3Denum target, GC3Duint index, WebGLBuffer* buffer);
+ void bindBufferRange(GC3Denum target, GC3Duint index, WebGLBuffer* buffer, GC3Dint64 offset, GC3Dint64 size);
+ WebGLGetInfo getIndexedParameter(GC3Denum target, GC3Duint index);
+ Uint32Array* getUniformIndices(WebGLProgram* program, Vector<String> uniformNames);
+ Int32Array* getActiveUniforms(WebGLProgram* program, Uint32Array* uniformIndices, GC3Denum pname);
+ GC3Duint getUniformBlockIndex(WebGLProgram* program, String uniformBlockName);
+ WebGLGetInfo getActiveUniformBlockParameter(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Denum pname);
+ WebGLGetInfo getActiveUniformBlockName(WebGLProgram* program, GC3Duint uniformBlockIndex);
+ void uniformBlockBinding(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Duint uniformBlockBinding);
+
+ /* Vertex Array Objects */
+ PassRefPtr<WebGLVertexArrayObject> createVertexArray();
+ void deleteVertexArray(WebGLVertexArrayObject* vertexArray);
+ GC3Dboolean isVertexArray(WebGLVertexArrayObject* vertexArray);
+ void bindVertexArray(WebGLVertexArrayObject* vertexArray);
};
} // namespace WebCore
Modified: trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.idl (179141 => 179142)
--- trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.idl 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.idl 2015-01-26 22:03:00 UTC (rev 179142)
@@ -23,12 +23,434 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-typedef long long GLint64;
+typedef unsigned long GLenum;
+typedef boolean GLboolean;
+typedef unsigned long GLbitfield;
+typedef byte GLbyte;
+typedef short GLshort;
+typedef long GLint;
+typedef long GLsizei;
+typedef long long GLintptr;
+typedef long long GLsizeiptr;
+typedef long long GLint64;
+typedef octet GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned long GLuint;
typedef unsigned long long GLuint64;
+typedef unrestricted float GLfloat;
+typedef unrestricted float GLclampf;
[
Conditional=WEBGL,
JSCustomMarkFunction,
DoNotCheckConstants,
] interface WebGL2RenderingContext : WebGLRenderingContextBase {
+ const GLenum READ_BUFFER = 0x0C02;
+ const GLenum UNPACK_ROW_LENGTH = 0x0CF2;
+ const GLenum UNPACK_SKIP_ROWS = 0x0CF3;
+ const GLenum UNPACK_SKIP_PIXELS = 0x0CF4;
+ const GLenum PACK_ROW_LENGTH = 0x0D02;
+ const GLenum PACK_SKIP_ROWS = 0x0D03;
+ const GLenum PACK_SKIP_PIXELS = 0x0D04;
+ const GLenum COLOR = 0x1800;
+ const GLenum DEPTH = 0x1801;
+ const GLenum STENCIL = 0x1802;
+ const GLenum RED = 0x1903;
+ const GLenum RGB8 = 0x8051;
+ const GLenum RGBA8 = 0x8058;
+ const GLenum RGB10_A2 = 0x8059;
+ const GLenum TEXTURE_BINDING_3D = 0x806A;
+ const GLenum UNPACK_SKIP_IMAGES = 0x806D;
+ const GLenum UNPACK_IMAGE_HEIGHT = 0x806E;
+ const GLenum TEXTURE_3D = 0x806F;
+ const GLenum TEXTURE_WRAP_R = 0x8072;
+ const GLenum MAX_3D_TEXTURE_SIZE = 0x8073;
+ const GLenum UNSIGNED_INT_2_10_10_10_REV = 0x8368;
+ const GLenum MAX_ELEMENTS_VERTICES = 0x80E8;
+ const GLenum MAX_ELEMENTS_INDICES = 0x80E9;
+ const GLenum TEXTURE_MIN_LOD = 0x813A;
+ const GLenum TEXTURE_MAX_LOD = 0x813B;
+ const GLenum TEXTURE_BASE_LEVEL = 0x813C;
+ const GLenum TEXTURE_MAX_LEVEL = 0x813D;
+ const GLenum MIN = 0x8007;
+ const GLenum MAX = 0x8008;
+ const GLenum DEPTH_COMPONENT24 = 0x81A6;
+ const GLenum MAX_TEXTURE_LOD_BIAS = 0x84FD;
+ const GLenum TEXTURE_COMPARE_MODE = 0x884C;
+ const GLenum TEXTURE_COMPARE_FUNC = 0x884D;
+ const GLenum CURRENT_QUERY = 0x8865;
+ const GLenum QUERY_RESULT = 0x8866;
+ const GLenum QUERY_RESULT_AVAILABLE = 0x8867;
+ const GLenum STREAM_READ = 0x88E1;
+ const GLenum STREAM_COPY = 0x88E2;
+ const GLenum STATIC_READ = 0x88E5;
+ const GLenum STATIC_COPY = 0x88E6;
+ const GLenum DYNAMIC_READ = 0x88E9;
+ const GLenum DYNAMIC_COPY = 0x88EA;
+ const GLenum MAX_DRAW_BUFFERS = 0x8824;
+ const GLenum DRAW_BUFFER0 = 0x8825;
+ const GLenum DRAW_BUFFER1 = 0x8826;
+ const GLenum DRAW_BUFFER2 = 0x8827;
+ const GLenum DRAW_BUFFER3 = 0x8828;
+ const GLenum DRAW_BUFFER4 = 0x8829;
+ const GLenum DRAW_BUFFER5 = 0x882A;
+ const GLenum DRAW_BUFFER6 = 0x882B;
+ const GLenum DRAW_BUFFER7 = 0x882C;
+ const GLenum DRAW_BUFFER8 = 0x882D;
+ const GLenum DRAW_BUFFER9 = 0x882E;
+ const GLenum DRAW_BUFFER10 = 0x882F;
+ const GLenum DRAW_BUFFER11 = 0x8830;
+ const GLenum DRAW_BUFFER12 = 0x8831;
+ const GLenum DRAW_BUFFER13 = 0x8832;
+ const GLenum DRAW_BUFFER14 = 0x8833;
+ const GLenum DRAW_BUFFER15 = 0x8834;
+ const GLenum MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49;
+ const GLenum MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A;
+ const GLenum SAMPLER_3D = 0x8B5F;
+ const GLenum SAMPLER_2D_SHADOW = 0x8B62;
+ const GLenum FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B;
+ const GLenum PIXEL_PACK_BUFFER = 0x88EB;
+ const GLenum PIXEL_UNPACK_BUFFER = 0x88EC;
+ const GLenum PIXEL_PACK_BUFFER_BINDING = 0x88ED;
+ const GLenum PIXEL_UNPACK_BUFFER_BINDING = 0x88EF;
+ const GLenum FLOAT_MAT2x3 = 0x8B65;
+ const GLenum FLOAT_MAT2x4 = 0x8B66;
+ const GLenum FLOAT_MAT3x2 = 0x8B67;
+ const GLenum FLOAT_MAT3x4 = 0x8B68;
+ const GLenum FLOAT_MAT4x2 = 0x8B69;
+ const GLenum FLOAT_MAT4x3 = 0x8B6A;
+ const GLenum SRGB = 0x8C40;
+ const GLenum SRGB8 = 0x8C41;
+ const GLenum SRGB8_ALPHA8 = 0x8C43;
+ const GLenum COMPARE_REF_TO_TEXTURE = 0x884E;
+ const GLenum RGBA32F = 0x8814;
+ const GLenum RGB32F = 0x8815;
+ const GLenum RGBA16F = 0x881A;
+ const GLenum RGB16F = 0x881B;
+ const GLenum VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD;
+ const GLenum MAX_ARRAY_TEXTURE_LAYERS = 0x88FF;
+ const GLenum MIN_PROGRAM_TEXEL_OFFSET = 0x8904;
+ const GLenum MAX_PROGRAM_TEXEL_OFFSET = 0x8905;
+ const GLenum MAX_VARYING_COMPONENTS = 0x8B4B;
+ const GLenum TEXTURE_2D_ARRAY = 0x8C1A;
+ const GLenum TEXTURE_BINDING_2D_ARRAY = 0x8C1D;
+ const GLenum R11F_G11F_B10F = 0x8C3A;
+ const GLenum UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B;
+ const GLenum RGB9_E5 = 0x8C3D;
+ const GLenum UNSIGNED_INT_5_9_9_9_REV = 0x8C3E;
+ const GLenum TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F;
+ const GLenum MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80;
+ const GLenum TRANSFORM_FEEDBACK_VARYINGS = 0x8C83;
+ const GLenum TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84;
+ const GLenum TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85;
+ const GLenum TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88;
+ const GLenum RASTERIZER_DISCARD = 0x8C89;
+ const GLenum MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A;
+ const GLenum MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B;
+ const GLenum INTERLEAVED_ATTRIBS = 0x8C8C;
+ const GLenum SEPARATE_ATTRIBS = 0x8C8D;
+ const GLenum TRANSFORM_FEEDBACK_BUFFER = 0x8C8E;
+ const GLenum TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F;
+ const GLenum RGBA32UI = 0x8D70;
+ const GLenum RGB32UI = 0x8D71;
+ const GLenum RGBA16UI = 0x8D76;
+ const GLenum RGB16UI = 0x8D77;
+ const GLenum RGBA8UI = 0x8D7C;
+ const GLenum RGB8UI = 0x8D7D;
+ const GLenum RGBA32I = 0x8D82;
+ const GLenum RGB32I = 0x8D83;
+ const GLenum RGBA16I = 0x8D88;
+ const GLenum RGB16I = 0x8D89;
+ const GLenum RGBA8I = 0x8D8E;
+ const GLenum RGB8I = 0x8D8F;
+ const GLenum RED_INTEGER = 0x8D94;
+ const GLenum RGB_INTEGER = 0x8D98;
+ const GLenum RGBA_INTEGER = 0x8D99;
+ const GLenum SAMPLER_2D_ARRAY = 0x8DC1;
+ const GLenum SAMPLER_2D_ARRAY_SHADOW = 0x8DC4;
+ const GLenum SAMPLER_CUBE_SHADOW = 0x8DC5;
+ const GLenum UNSIGNED_INT_VEC2 = 0x8DC6;
+ const GLenum UNSIGNED_INT_VEC3 = 0x8DC7;
+ const GLenum UNSIGNED_INT_VEC4 = 0x8DC8;
+ const GLenum INT_SAMPLER_2D = 0x8DCA;
+ const GLenum INT_SAMPLER_3D = 0x8DCB;
+ const GLenum INT_SAMPLER_CUBE = 0x8DCC;
+ const GLenum INT_SAMPLER_2D_ARRAY = 0x8DCF;
+ const GLenum UNSIGNED_INT_SAMPLER_2D = 0x8DD2;
+ const GLenum UNSIGNED_INT_SAMPLER_3D = 0x8DD3;
+ const GLenum UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4;
+ const GLenum UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7;
+ const GLenum DEPTH_COMPONENT32F = 0x8CAC;
+ const GLenum DEPTH32F_STENCIL8 = 0x8CAD;
+ const GLenum FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;
+ const GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210;
+ const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211;
+ const GLenum FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212;
+ const GLenum FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213;
+ const GLenum FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214;
+ const GLenum FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215;
+ const GLenum FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216;
+ const GLenum FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217;
+ const GLenum FRAMEBUFFER_DEFAULT = 0x8218;
+ const GLenum DEPTH_STENCIL_ATTACHMENT = 0x821A;
+ const GLenum DEPTH_STENCIL = 0x84F9;
+ const GLenum UNSIGNED_INT_24_8 = 0x84FA;
+ const GLenum DEPTH24_STENCIL8 = 0x88F0;
+ const GLenum UNSIGNED_NORMALIZED = 0x8C17;
+ const GLenum DRAW_FRAMEBUFFER_BINDING = 0x8CA6; /* Same as FRAMEBUFFER_BINDING */
+ const GLenum READ_FRAMEBUFFER = 0x8CA8;
+ const GLenum DRAW_FRAMEBUFFER = 0x8CA9;
+ const GLenum READ_FRAMEBUFFER_BINDING = 0x8CAA;
+ const GLenum RENDERBUFFER_SAMPLES = 0x8CAB;
+ const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4;
+ const GLenum MAX_COLOR_ATTACHMENTS = 0x8CDF;
+ const GLenum COLOR_ATTACHMENT1 = 0x8CE1;
+ const GLenum COLOR_ATTACHMENT2 = 0x8CE2;
+ const GLenum COLOR_ATTACHMENT3 = 0x8CE3;
+ const GLenum COLOR_ATTACHMENT4 = 0x8CE4;
+ const GLenum COLOR_ATTACHMENT5 = 0x8CE5;
+ const GLenum COLOR_ATTACHMENT6 = 0x8CE6;
+ const GLenum COLOR_ATTACHMENT7 = 0x8CE7;
+ const GLenum COLOR_ATTACHMENT8 = 0x8CE8;
+ const GLenum COLOR_ATTACHMENT9 = 0x8CE9;
+ const GLenum COLOR_ATTACHMENT10 = 0x8CEA;
+ const GLenum COLOR_ATTACHMENT11 = 0x8CEB;
+ const GLenum COLOR_ATTACHMENT12 = 0x8CEC;
+ const GLenum COLOR_ATTACHMENT13 = 0x8CED;
+ const GLenum COLOR_ATTACHMENT14 = 0x8CEE;
+ const GLenum COLOR_ATTACHMENT15 = 0x8CEF;
+ const GLenum FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56;
+ const GLenum MAX_SAMPLES = 0x8D57;
+ const GLenum HALF_FLOAT = 0x140B;
+ const GLenum RG = 0x8227;
+ const GLenum RG_INTEGER = 0x8228;
+ const GLenum R8 = 0x8229;
+ const GLenum RG8 = 0x822B;
+ const GLenum R16F = 0x822D;
+ const GLenum R32F = 0x822E;
+ const GLenum RG16F = 0x822F;
+ const GLenum RG32F = 0x8230;
+ const GLenum R8I = 0x8231;
+ const GLenum R8UI = 0x8232;
+ const GLenum R16I = 0x8233;
+ const GLenum R16UI = 0x8234;
+ const GLenum R32I = 0x8235;
+ const GLenum R32UI = 0x8236;
+ const GLenum RG8I = 0x8237;
+ const GLenum RG8UI = 0x8238;
+ const GLenum RG16I = 0x8239;
+ const GLenum RG16UI = 0x823A;
+ const GLenum RG32I = 0x823B;
+ const GLenum RG32UI = 0x823C;
+ const GLenum VERTEX_ARRAY_BINDING = 0x85B5;
+ const GLenum R8_SNORM = 0x8F94;
+ const GLenum RG8_SNORM = 0x8F95;
+ const GLenum RGB8_SNORM = 0x8F96;
+ const GLenum RGBA8_SNORM = 0x8F97;
+ const GLenum SIGNED_NORMALIZED = 0x8F9C;
+ const GLenum PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69;
+ const GLenum COPY_READ_BUFFER = 0x8F36;
+ const GLenum COPY_WRITE_BUFFER = 0x8F37;
+ const GLenum COPY_READ_BUFFER_BINDING = 0x8F36; /* Same as COPY_READ_BUFFER */
+ const GLenum COPY_WRITE_BUFFER_BINDING = 0x8F37; /* Same as COPY_WRITE_BUFFER */
+ const GLenum UNIFORM_BUFFER = 0x8A11;
+ const GLenum UNIFORM_BUFFER_BINDING = 0x8A28;
+ const GLenum UNIFORM_BUFFER_START = 0x8A29;
+ const GLenum UNIFORM_BUFFER_SIZE = 0x8A2A;
+ const GLenum MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B;
+ const GLenum MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D;
+ const GLenum MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E;
+ const GLenum MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F;
+ const GLenum MAX_UNIFORM_BLOCK_SIZE = 0x8A30;
+ const GLenum MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31;
+ const GLenum MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33;
+ const GLenum UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34;
+ const GLenum ACTIVE_UNIFORM_BLOCKS = 0x8A36;
+ const GLenum UNIFORM_TYPE = 0x8A37;
+ const GLenum UNIFORM_SIZE = 0x8A38;
+ const GLenum UNIFORM_BLOCK_INDEX = 0x8A3A;
+ const GLenum UNIFORM_OFFSET = 0x8A3B;
+ const GLenum UNIFORM_ARRAY_STRIDE = 0x8A3C;
+ const GLenum UNIFORM_MATRIX_STRIDE = 0x8A3D;
+ const GLenum UNIFORM_IS_ROW_MAJOR = 0x8A3E;
+ const GLenum UNIFORM_BLOCK_BINDING = 0x8A3F;
+ const GLenum UNIFORM_BLOCK_DATA_SIZE = 0x8A40;
+ const GLenum UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42;
+ const GLenum UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43;
+ const GLenum UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44;
+ const GLenum UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46;
+ const GLenum INVALID_INDEX = 0xFFFFFFFF;
+ const GLenum MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122;
+ const GLenum MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125;
+ const GLenum MAX_SERVER_WAIT_TIMEOUT = 0x9111;
+ const GLenum OBJECT_TYPE = 0x9112;
+ const GLenum SYNC_CONDITION = 0x9113;
+ const GLenum SYNC_STATUS = 0x9114;
+ const GLenum SYNC_FLAGS = 0x9115;
+ const GLenum SYNC_FENCE = 0x9116;
+ const GLenum SYNC_GPU_COMMANDS_COMPLETE = 0x9117;
+ const GLenum UNSIGNALED = 0x9118;
+ const GLenum SIGNALED = 0x9119;
+ const GLenum ALREADY_SIGNALED = 0x911A;
+ const GLenum TIMEOUT_EXPIRED = 0x911B;
+ const GLenum CONDITION_SATISFIED = 0x911C;
+ const GLenum WAIT_FAILED = 0x911D;
+ const GLenum SYNC_FLUSH_COMMANDS_BIT = 0x00000001;
+ const GLenum VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE;
+ const GLenum ANY_SAMPLES_PASSED = 0x8C2F;
+ const GLenum ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A;
+ const GLenum SAMPLER_BINDING = 0x8919;
+ const GLenum RGB10_A2UI = 0x906F;
+ const GLenum TEXTURE_SWIZZLE_R = 0x8E42;
+ const GLenum TEXTURE_SWIZZLE_G = 0x8E43;
+ const GLenum TEXTURE_SWIZZLE_B = 0x8E44;
+ const GLenum TEXTURE_SWIZZLE_A = 0x8E45;
+ const GLenum GREEN = 0x1904;
+ const GLenum BLUE = 0x1905;
+ const GLenum INT_2_10_10_10_REV = 0x8D9F;
+ const GLenum TRANSFORM_FEEDBACK = 0x8E22;
+ const GLenum TRANSFORM_FEEDBACK_PAUSED = 0x8E23;
+ const GLenum TRANSFORM_FEEDBACK_ACTIVE = 0x8E24;
+ const GLenum TRANSFORM_FEEDBACK_BINDING = 0x8E25;
+ const GLenum COMPRESSED_R11_EAC = 0x9270;
+ const GLenum COMPRESSED_SIGNED_R11_EAC = 0x9271;
+ const GLenum COMPRESSED_RG11_EAC = 0x9272;
+ const GLenum COMPRESSED_SIGNED_RG11_EAC = 0x9273;
+ const GLenum COMPRESSED_RGB8_ETC2 = 0x9274;
+ const GLenum COMPRESSED_SRGB8_ETC2 = 0x9275;
+ const GLenum COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276;
+ const GLenum COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
+ const GLenum COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
+ const GLenum COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
+ const GLenum TEXTURE_IMMUTABLE_FORMAT = 0x912F;
+ const GLenum MAX_ELEMENT_INDEX = 0x8D6B;
+ const GLenum NUM_SAMPLE_COUNTS = 0x9380;
+ const GLenum TEXTURE_IMMUTABLE_LEVELS = 0x82DF;
+
+ const GLuint64 TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF;
+
+ /* Buffer objects */
+ [StrictTypeChecking] void copyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+ // MapBufferRange, in particular its read-only and write-only modes,
+ // can not be exposed safely to _javascript_. GetBufferSubData
+ // replaces it for the purpose of fetching data back from the GPU.
+ [StrictTypeChecking] void getBufferSubData(GLenum target, GLintptr offset, ArrayBufferView returnedData);
+ [StrictTypeChecking] void getBufferSubData(GLenum target, GLintptr offset, ArrayBuffer returnedData);
+
+ /* Framebuffer objects */
+ [StrictTypeChecking, Custom] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
+ [StrictTypeChecking] void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+ [StrictTypeChecking] void framebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+ [StrictTypeChecking, Custom] any getInternalformatParameter(GLenum target, GLenum internalformat, GLenum pname);
+ [StrictTypeChecking] void invalidateFramebuffer(GLenum target, sequence<GLenum> attachments);
+ [StrictTypeChecking] void invalidateSubFramebuffer(GLenum target, sequence<GLenum> attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+ [StrictTypeChecking] void readBuffer(GLenum src);
+
+ /* Renderbuffer objects */
+ [StrictTypeChecking] void renderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+
+ /* Texture objects */
+ [StrictTypeChecking] void texStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+ [StrictTypeChecking] void texStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+ [StrictTypeChecking] void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);
+ [StrictTypeChecking] void texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, ArrayBufferView? pixels);
+ [StrictTypeChecking] void texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, ImageData? source);
+ [StrictTypeChecking] void texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLImageElement? source);
+ [StrictTypeChecking] void texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLCanvasElement? source);
+ [StrictTypeChecking] void texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLVideoElement? source);
+ [StrictTypeChecking] void copyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ [StrictTypeChecking] void compressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, ArrayBufferView data);
+ [StrictTypeChecking] void compressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, ArrayBufferView data);
+
+ /* Programs and shaders */
+ [StrictTypeChecking] GLint getFragDataLocation(WebGLProgram? program, DOMString name);
+
+ /* Uniforms and attributes */
+ [StrictTypeChecking] void uniform1ui(WebGLUniformLocation? location, GLuint v0);
+ [StrictTypeChecking] void uniform2ui(WebGLUniformLocation? location, GLuint v0, GLuint v1);
+ [StrictTypeChecking] void uniform3ui(WebGLUniformLocation? location, GLuint v0, GLuint v1, GLuint v2);
+ [StrictTypeChecking] void uniform4ui(WebGLUniformLocation? location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ [StrictTypeChecking] void uniform1uiv(WebGLUniformLocation? location, Uint32Array value);
+ [StrictTypeChecking] void uniform2uiv(WebGLUniformLocation? location, Uint32Array value);
+ [StrictTypeChecking] void uniform3uiv(WebGLUniformLocation? location, Uint32Array value);
+ [StrictTypeChecking] void uniform4uiv(WebGLUniformLocation? location, Uint32Array value);
+ [StrictTypeChecking] void uniformMatrix2x3fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void uniformMatrix3x2fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void uniformMatrix2x4fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void uniformMatrix4x2fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void uniformMatrix3x4fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void uniformMatrix4x3fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array value);
+ [StrictTypeChecking] void vertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
+ [StrictTypeChecking] void vertexAttribI4iv(GLuint index, Int32Array v);
+ [StrictTypeChecking] void vertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ [StrictTypeChecking] void vertexAttribI4uiv(GLuint index, Uint32Array v);
+ [StrictTypeChecking] void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+
+ /* Writing to the drawing buffer */
+ [StrictTypeChecking] void vertexAttribDivisor(GLuint index, GLuint divisor);
+ [StrictTypeChecking] void drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
+ [StrictTypeChecking] void drawElementsInstanced(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei instanceCount);
+ [StrictTypeChecking] void drawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLintptr offset);
+
+ /* Multiple Render Targets */
+ [StrictTypeChecking] void drawBuffers(sequence<GLenum> buffers);
+ [StrictTypeChecking] void clearBufferiv(GLenum buffer, GLint drawbuffer, Int32Array value);
+ [StrictTypeChecking] void clearBufferuiv(GLenum buffer, GLint drawbuffer, Uint32Array value);
+ [StrictTypeChecking] void clearBufferfv(GLenum buffer, GLint drawbuffer, Float32Array value);
+ [StrictTypeChecking] void clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+
+ /* Query Objects */
+ [StrictTypeChecking] WebGLQuery createQuery();
+ [StrictTypeChecking] void deleteQuery(WebGLQuery? query);
+ [StrictTypeChecking] GLboolean isQuery(WebGLQuery? query);
+ [StrictTypeChecking] void beginQuery(GLenum target, WebGLQuery? query);
+ [StrictTypeChecking] void endQuery(GLenum target);
+ [StrictTypeChecking] WebGLQuery getQuery(GLenum target, GLenum pname);
+ [StrictTypeChecking, Custom] any getQueryParameter(WebGLQuery? query, GLenum pname);
+
+ /* Sampler Objects */
+ [StrictTypeChecking] WebGLSampler createSampler();
+ [StrictTypeChecking] void deleteSampler(WebGLSampler? sampler);
+ [StrictTypeChecking] GLboolean isSampler(WebGLSampler? sampler);
+ [StrictTypeChecking] void bindSampler(GLuint unit, WebGLSampler? sampler);
+ [StrictTypeChecking] void samplerParameteri(WebGLSampler? sampler, GLenum pname, GLint param);
+ [StrictTypeChecking] void samplerParameterf(WebGLSampler? sampler, GLenum pname, GLfloat param);
+ [StrictTypeChecking, Custom] any getSamplerParameter(WebGLSampler? sampler, GLenum pname);
+
+ /* Sync objects */
+ [StrictTypeChecking] WebGLSync fenceSync(GLenum condition, GLbitfield flags);
+ [StrictTypeChecking] GLboolean isSync(WebGLSync? sync);
+ [StrictTypeChecking] void deleteSync(WebGLSync? sync);
+ [StrictTypeChecking] GLenum clientWaitSync(WebGLSync? sync, GLbitfield flags, GLuint64 timeout);
+ [StrictTypeChecking] void waitSync(WebGLSync? sync, GLbitfield flags, GLuint64 timeout);
+ [StrictTypeChecking, Custom] any getSyncParameter(WebGLSync? sync, GLenum pname);
+
+ /* Transform Feedback */
+ [StrictTypeChecking] WebGLTransformFeedback createTransformFeedback();
+ [StrictTypeChecking] void deleteTransformFeedback(WebGLTransformFeedback? id);
+ [StrictTypeChecking] GLboolean isTransformFeedback(WebGLTransformFeedback? id);
+ [StrictTypeChecking] void bindTransformFeedback(GLenum target, WebGLTransformFeedback? id);
+ [StrictTypeChecking] void beginTransformFeedback(GLenum primitiveMode);
+ [StrictTypeChecking] void endTransformFeedback();
+ [StrictTypeChecking] void transformFeedbackVaryings(WebGLProgram? program, sequence<DOMString> varyings, GLenum bufferMode);
+ [StrictTypeChecking] WebGLActiveInfo getTransformFeedbackVarying(WebGLProgram? program, GLuint index);
+ [StrictTypeChecking] void pauseTransformFeedback();
+ [StrictTypeChecking] void resumeTransformFeedback();
+
+ /* Uniform Buffer Objects and Transform Feedback Buffers */
+ [StrictTypeChecking] void bindBufferBase(GLenum target, GLuint index, WebGLBuffer? buffer);
+ [StrictTypeChecking] void bindBufferRange(GLenum target, GLuint index, WebGLBuffer? buffer, GLintptr offset, GLsizeiptr size);
+ [StrictTypeChecking, Custom] any getIndexedParameter(GLenum target, GLuint index);
+ [StrictTypeChecking] Uint32Array getUniformIndices(WebGLProgram? program, sequence<DOMString> uniformNames);
+ [StrictTypeChecking] Int32Array getActiveUniforms(WebGLProgram? program, Uint32Array uniformIndices, GLenum pname);
+ [StrictTypeChecking] GLuint getUniformBlockIndex(WebGLProgram? program, DOMString uniformBlockName);
+ [StrictTypeChecking, Custom] any getActiveUniformBlockParameter(WebGLProgram? program, GLuint uniformBlockIndex, GLenum pname);
+ [StrictTypeChecking, Custom] any getActiveUniformBlockName(WebGLProgram? program, GLuint uniformBlockIndex);
+ [StrictTypeChecking] void uniformBlockBinding(WebGLProgram? program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+
+ /* Vertex Array Objects */
+ [StrictTypeChecking] WebGLVertexArrayObject createVertexArray();
+ [StrictTypeChecking] void deleteVertexArray(WebGLVertexArrayObject? vertexArray);
+ [StrictTypeChecking] GLboolean isVertexArray(WebGLVertexArrayObject? vertexArray);
+ [StrictTypeChecking] void bindVertexArray(WebGLVertexArrayObject? vertexArray);
};
Modified: trunk/Source/WebCore/platform/graphics/GraphicsTypes3D.h (179141 => 179142)
--- trunk/Source/WebCore/platform/graphics/GraphicsTypes3D.h 2015-01-26 21:42:40 UTC (rev 179141)
+++ trunk/Source/WebCore/platform/graphics/GraphicsTypes3D.h 2015-01-26 22:03:00 UTC (rev 179142)
@@ -46,6 +46,8 @@
typedef intptr_t GC3Dintptr;
typedef intptr_t GC3Dsizeiptr;
typedef char GC3Dchar;
+typedef long long GC3Dint64;
+typedef unsigned long long GC3Duint64;
typedef GC3Duint Platform3DObject;
