summaryrefslogtreecommitdiffstats
path: root/dom/canvas/WebGL2Context.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/canvas/WebGL2Context.h')
-rw-r--r--dom/canvas/WebGL2Context.h433
1 files changed, 433 insertions, 0 deletions
diff --git a/dom/canvas/WebGL2Context.h b/dom/canvas/WebGL2Context.h
new file mode 100644
index 000000000..8bb6d5c95
--- /dev/null
+++ b/dom/canvas/WebGL2Context.h
@@ -0,0 +1,433 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGL2CONTEXT_H_
+#define WEBGL2CONTEXT_H_
+
+#include "WebGLContext.h"
+
+namespace mozilla {
+
+class ErrorResult;
+class WebGLSampler;
+class WebGLSync;
+class WebGLTransformFeedback;
+class WebGLVertexArrayObject;
+namespace dom {
+class OwningUnsignedLongOrUint32ArrayOrBoolean;
+class OwningWebGLBufferOrLongLong;
+} // namespace dom
+
+class WebGL2Context
+ : public WebGLContext
+{
+public:
+
+ virtual ~WebGL2Context();
+
+ static bool IsSupported();
+ static WebGL2Context* Create();
+
+ virtual bool IsWebGL2() const override
+ {
+ return true;
+ }
+
+ // -------------------------------------------------------------------------
+ // IMPLEMENT nsWrapperCache
+
+ virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto) override;
+
+ // -------------------------------------------------------------------------
+ // Buffer objects - WebGL2ContextBuffers.cpp
+
+ void CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+ GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+
+private:
+ template<typename BufferT>
+ void GetBufferSubDataT(GLenum target, GLintptr offset, const BufferT& data);
+
+public:
+ void GetBufferSubData(GLenum target, GLintptr srcByteOffset,
+ const dom::ArrayBufferView& dstData, GLuint dstElemOffset,
+ GLuint dstElemCountOverride);
+
+ // -------------------------------------------------------------------------
+ // Framebuffer objects - WebGL2ContextFramebuffers.cpp
+
+ void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+ GLbitfield mask, GLenum filter);
+ void FramebufferTextureLayer(GLenum target, GLenum attachment, WebGLTexture* texture, GLint level, GLint layer);
+
+ virtual JS::Value GetFramebufferAttachmentParameter(JSContext* cx, GLenum target,
+ GLenum attachment, GLenum pname,
+ ErrorResult& rv) override;
+ // Make the inline version from the superclass visible here.
+ using WebGLContext::GetFramebufferAttachmentParameter;
+
+ void InvalidateFramebuffer(GLenum target, const dom::Sequence<GLenum>& attachments,
+ ErrorResult& rv);
+ void InvalidateSubFramebuffer (GLenum target, const dom::Sequence<GLenum>& attachments, GLint x, GLint y,
+ GLsizei width, GLsizei height, ErrorResult& rv);
+ void ReadBuffer(GLenum mode);
+
+
+ // -------------------------------------------------------------------------
+ // Renderbuffer objects - WebGL2ContextRenderbuffers.cpp
+
+ void GetInternalformatParameter(JSContext*, GLenum target, GLenum internalformat,
+ GLenum pname, JS::MutableHandleValue retval,
+ ErrorResult& rv);
+ void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat,
+ GLsizei width, GLsizei height);
+
+
+ // -------------------------------------------------------------------------
+ // Texture objects - WebGL2ContextTextures.cpp
+
+ void TexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width,
+ GLsizei height)
+ {
+ const char funcName[] = "TexStorage2D";
+ const uint8_t funcDims = 2;
+ const GLsizei depth = 1;
+ TexStorage(funcName, funcDims, target, levels, internalFormat, width, height,
+ depth);
+ }
+
+ void TexStorage3D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width,
+ GLsizei height, GLsizei depth)
+ {
+ const char funcName[] = "TexStorage3D";
+ const uint8_t funcDims = 3;
+ TexStorage(funcName, funcDims, target, levels, internalFormat, width, height,
+ depth);
+ }
+
+protected:
+ void TexStorage(const char* funcName, uint8_t funcDims, GLenum target, GLsizei levels,
+ GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
+
+ ////////////////////////////////////
+
+public:
+ template<typename T>
+ void CompressedTexImage3D(GLenum target, GLint level, GLenum internalFormat,
+ GLsizei width, GLsizei height, GLsizei depth, GLint border,
+ const T& anySrc, GLuint viewElemOffset = 0,
+ GLuint viewElemLengthOverride = 0)
+ {
+ const char funcName[] = "compressedTexImage3D";
+ const uint8_t funcDims = 3;
+ const TexImageSourceAdapter src(&anySrc, viewElemOffset, viewElemLengthOverride);
+ CompressedTexImage(funcName, funcDims, target, level, internalFormat, width,
+ height, depth, border, src);
+ }
+
+ template<typename T>
+ void CompressedTexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset,
+ GLint zOffset, GLsizei width, GLsizei height,
+ GLsizei depth, GLenum unpackFormat, const T& anySrc,
+ GLuint viewElemOffset = 0,
+ GLuint viewElemLengthOverride = 0)
+ {
+ const char funcName[] = "compressedTexSubImage3D";
+ const uint8_t funcDims = 3;
+ const TexImageSourceAdapter src(&anySrc, viewElemOffset, viewElemLengthOverride);
+ CompressedTexSubImage(funcName, funcDims, target, level, xOffset, yOffset,
+ zOffset, width, height, depth, unpackFormat, src);
+ }
+
+ ////////////////////////////////////
+
+ void CopyTexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset,
+ GLint zOffset, GLint x, GLint y, GLsizei width,
+ GLsizei height)
+ {
+ const char funcName[] = "copyTexSubImage3D";
+ const uint8_t funcDims = 3;
+ CopyTexSubImage(funcName, funcDims, target, level, xOffset, yOffset, zOffset,
+ x, y, width, height);
+ }
+
+ ////////////////////////////////////
+
+ template<typename T>
+ void TexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width,
+ GLsizei height, GLsizei depth, GLint border, GLenum unpackFormat,
+ GLenum unpackType, const T& anySrc, ErrorResult& out_error)
+ {
+ const TexImageSourceAdapter src(&anySrc, &out_error);
+ TexImage3D(target, level, internalFormat, width, height, depth, border,
+ unpackFormat, unpackType, src);
+ }
+
+ void TexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width,
+ GLsizei height, GLsizei depth, GLint border, GLenum unpackFormat,
+ GLenum unpackType, const dom::ArrayBufferView& view,
+ GLuint viewElemOffset, ErrorResult&)
+ {
+ const TexImageSourceAdapter src(&view, viewElemOffset);
+ TexImage3D(target, level, internalFormat, width, height, depth, border,
+ unpackFormat, unpackType, src);
+ }
+
+protected:
+ void TexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width,
+ GLsizei height, GLsizei depth, GLint border, GLenum unpackFormat,
+ GLenum unpackType, const TexImageSource& src)
+ {
+ const char funcName[] = "texImage3D";
+ const uint8_t funcDims = 3;
+ TexImage(funcName, funcDims, target, level, internalFormat, width, height, depth,
+ border, unpackFormat, unpackType, src);
+ }
+
+ ////////////////////////////////////
+
+public:
+ template<typename T>
+ void TexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset,
+ GLint zOffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum unpackFormat, GLenum unpackType, const T& anySrc,
+ ErrorResult& out_error)
+ {
+ const TexImageSourceAdapter src(&anySrc, &out_error);
+ TexSubImage3D(target, level, xOffset, yOffset, zOffset, width, height, depth,
+ unpackFormat, unpackType, src);
+ }
+
+ void TexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset,
+ GLint zOffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum unpackFormat, GLenum unpackType,
+ const dom::Nullable<dom::ArrayBufferView>& maybeSrcView,
+ GLuint srcElemOffset, ErrorResult&)
+ {
+ if (IsContextLost())
+ return;
+
+ if (!ValidateNonNull("texSubImage3D", maybeSrcView))
+ return;
+ const auto& srcView = maybeSrcView.Value();
+
+ const TexImageSourceAdapter src(&srcView, srcElemOffset);
+ TexSubImage3D(target, level, xOffset, yOffset, zOffset, width, height, depth,
+ unpackFormat, unpackType, src);
+ }
+
+protected:
+ void TexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset,
+ GLint zOffset, GLsizei width, GLsizei height, GLsizei depth,
+ GLenum unpackFormat, GLenum unpackType, const TexImageSource& src)
+ {
+ const char funcName[] = "texSubImage3D";
+ const uint8_t funcDims = 3;
+ TexSubImage(funcName, funcDims, target, level, xOffset, yOffset, zOffset, width,
+ height, depth, unpackFormat, unpackType, src);
+ }
+
+public:
+ // -------------------------------------------------------------------------
+ // Programs and shaders - WebGL2ContextPrograms.cpp
+ GLint GetFragDataLocation(const WebGLProgram& program, const nsAString& name);
+
+
+ // -------------------------------------------------------------------------
+ // Uniforms and attributes - WebGL2ContextUniforms.cpp
+ void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+
+ ////////////////
+
+ // GL 3.0 & ES 3.0
+ void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w,
+ const char* funcName = nullptr);
+ void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w,
+ const char* funcName = nullptr);
+
+ void VertexAttribI4iv(GLuint index, const Int32ListU& list) {
+ const auto& arr = Int32Arr::From(list);
+ if (!ValidateAttribArraySetter("vertexAttribI4iv", 4, arr.elemCount))
+ return;
+
+ const auto& itr = arr.elemBytes;
+ VertexAttribI4i(index, itr[0], itr[1], itr[2], itr[3]);
+ }
+
+ void VertexAttribI4uiv(GLuint index, const Uint32ListU& list) {
+ const auto& arr = Uint32Arr::From(list);
+ if (!ValidateAttribArraySetter("vertexAttribI4uiv", 4, arr.elemCount))
+ return;
+
+ const auto& itr = arr.elemBytes;
+ VertexAttribI4ui(index, itr[0], itr[1], itr[2], itr[3]);
+ }
+
+ // -------------------------------------------------------------------------
+ // Writing to the drawing buffer
+
+ /* Implemented in WebGLContext
+ void VertexAttribDivisor(GLuint index, GLuint divisor);
+ void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
+ void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei instanceCount);
+ */
+
+ void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
+ GLenum type, WebGLintptr byteOffset)
+ {
+ const char funcName[] = "drawRangeElements";
+ if (IsContextLost())
+ return;
+
+ if (end < start) {
+ ErrorInvalidValue("%s: end must be >= start.", funcName);
+ return;
+ }
+
+ DrawElements(mode, count, type, byteOffset, funcName);
+ }
+
+ // ------------------------------------------------------------------------
+ // Multiple Render Targets - WebGL2ContextMRTs.cpp
+ /* Implemented in WebGLContext
+ void DrawBuffers(const dom::Sequence<GLenum>& buffers);
+ */
+
+private:
+ bool ValidateClearBuffer(const char* funcName, GLenum buffer, GLint drawBuffer,
+ size_t availElemCount, GLuint elemOffset, GLenum funcType);
+
+ void ClearBufferfv(GLenum buffer, GLint drawBuffer, const Float32Arr& src,
+ GLuint srcElemOffset);
+ void ClearBufferiv(GLenum buffer, GLint drawBuffer, const Int32Arr& src,
+ GLuint srcElemOffset);
+ void ClearBufferuiv(GLenum buffer, GLint drawBuffer, const Uint32Arr& src,
+ GLuint srcElemOffset);
+
+public:
+ void ClearBufferfv(GLenum buffer, GLint drawBuffer, const Float32ListU& list,
+ GLuint srcElemOffset)
+ {
+ ClearBufferfv(buffer, drawBuffer, Float32Arr::From(list), srcElemOffset);
+ }
+ void ClearBufferiv(GLenum buffer, GLint drawBuffer, const Int32ListU& list,
+ GLuint srcElemOffset)
+ {
+ ClearBufferiv(buffer, drawBuffer, Int32Arr::From(list), srcElemOffset);
+ }
+ void ClearBufferuiv(GLenum buffer, GLint drawBuffer, const Uint32ListU& list,
+ GLuint srcElemOffset)
+ {
+ ClearBufferuiv(buffer, drawBuffer, Uint32Arr::From(list), srcElemOffset);
+ }
+
+ void ClearBufferfi(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil);
+
+ // -------------------------------------------------------------------------
+ // Sampler Objects - WebGL2ContextSamplers.cpp
+
+ already_AddRefed<WebGLSampler> CreateSampler();
+ void DeleteSampler(WebGLSampler* sampler);
+ bool IsSampler(const WebGLSampler* sampler);
+ void BindSampler(GLuint unit, WebGLSampler* sampler);
+ void SamplerParameteri(WebGLSampler& sampler, GLenum pname, GLint param);
+ void SamplerParameterf(WebGLSampler& sampler, GLenum pname, GLfloat param);
+ void GetSamplerParameter(JSContext*, const WebGLSampler& sampler, GLenum pname,
+ JS::MutableHandleValue retval);
+
+
+ // -------------------------------------------------------------------------
+ // Sync objects - WebGL2ContextSync.cpp
+
+ const GLuint64 kMaxClientWaitSyncTimeoutNS = 1000 * 1000 * 1000; // 1000ms in ns.
+
+ already_AddRefed<WebGLSync> FenceSync(GLenum condition, GLbitfield flags);
+ bool IsSync(const WebGLSync* sync);
+ void DeleteSync(WebGLSync* sync);
+ GLenum ClientWaitSync(const WebGLSync& sync, GLbitfield flags, GLuint64 timeout);
+ void WaitSync(const WebGLSync& sync, GLbitfield flags, GLint64 timeout);
+ void GetSyncParameter(JSContext*, const WebGLSync& sync, GLenum pname,
+ JS::MutableHandleValue retval);
+
+
+ // -------------------------------------------------------------------------
+ // Transform Feedback - WebGL2ContextTransformFeedback.cpp
+
+ already_AddRefed<WebGLTransformFeedback> CreateTransformFeedback();
+ void DeleteTransformFeedback(WebGLTransformFeedback* tf);
+ bool IsTransformFeedback(const WebGLTransformFeedback* tf);
+ void BindTransformFeedback(GLenum target, WebGLTransformFeedback* tf);
+ void BeginTransformFeedback(GLenum primitiveMode);
+ void EndTransformFeedback();
+ void PauseTransformFeedback();
+ void ResumeTransformFeedback();
+ void TransformFeedbackVaryings(WebGLProgram& program,
+ const dom::Sequence<nsString>& varyings,
+ GLenum bufferMode);
+ already_AddRefed<WebGLActiveInfo>
+ GetTransformFeedbackVarying(const WebGLProgram& program, GLuint index);
+
+
+ // -------------------------------------------------------------------------
+ // Uniform Buffer Objects and Transform Feedback Buffers - WebGL2ContextUniforms.cpp
+ // TODO(djg): Implemented in WebGLContext
+/*
+ void BindBufferBase(GLenum target, GLuint index, WebGLBuffer* buffer);
+ void BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buffer, GLintptr offset, GLsizeiptr size);
+*/
+ virtual JS::Value GetParameter(JSContext* cx, GLenum pname, ErrorResult& rv) override;
+ // Make the inline version from the superclass visible here.
+ using WebGLContext::GetParameter;
+ void GetIndexedParameter(JSContext* cx, GLenum target, GLuint index,
+ JS::MutableHandleValue retval, ErrorResult& rv);
+ void GetUniformIndices(const WebGLProgram& program,
+ const dom::Sequence<nsString>& uniformNames,
+ dom::Nullable< nsTArray<GLuint> >& retval);
+ void GetActiveUniforms(JSContext* cx, const WebGLProgram& program,
+ const dom::Sequence<GLuint>& uniformIndices, GLenum pname,
+ JS::MutableHandleValue retval);
+
+ GLuint GetUniformBlockIndex(const WebGLProgram& program,
+ const nsAString& uniformBlockName);
+ void GetActiveUniformBlockParameter(JSContext*, const WebGLProgram& program,
+ GLuint uniformBlockIndex, GLenum pname,
+ JS::MutableHandleValue retval, ErrorResult& rv);
+ void GetActiveUniformBlockName(const WebGLProgram& program, GLuint uniformBlockIndex,
+ nsAString& retval);
+ void UniformBlockBinding(WebGLProgram& program, GLuint uniformBlockIndex,
+ GLuint uniformBlockBinding);
+
+
+ // -------------------------------------------------------------------------
+ // Vertex Array Object - WebGL2ContextVAOs.cpp
+ // TODO(djg): Implemented in WebGLContext
+/*
+ already_AddRefed<WebGLVertexArrayObject> CreateVertexArray();
+ void DeleteVertexArray(WebGLVertexArrayObject* vertexArray);
+ bool IsVertexArray(WebGLVertexArrayObject* vertexArray);
+ void BindVertexArray(WebGLVertexArrayObject* vertexArray);
+*/
+
+private:
+ WebGL2Context();
+ virtual UniquePtr<webgl::FormatUsageAuthority>
+ CreateFormatUsage(gl::GLContext* gl) const override;
+
+ virtual bool IsTexParamValid(GLenum pname) const override;
+
+ void UpdateBoundQuery(GLenum target, WebGLQuery* query);
+
+ // CreateVertexArrayImpl is assumed to be infallible.
+ virtual WebGLVertexArray* CreateVertexArrayImpl() override;
+ virtual bool ValidateAttribPointerType(bool integerMode, GLenum type,
+ uint32_t* alignment,
+ const char* info) override;
+ virtual bool ValidateUniformMatrixTranspose(bool transpose, const char* info) override;
+};
+
+} // namespace mozilla
+
+#endif