1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef WebGL2RenderingContextBase_h
#define WebGL2RenderingContextBase_h
#include "modules/webgl/WebGLExtension.h"
#include "modules/webgl/WebGLRenderingContextBase.h"
namespace blink {
class WebGLTexture;
class WebGLActiveInfo;
class WebGLBuffer;
class WebGLProgram;
class WebGLQuery;
class WebGLSampler;
class WebGLSync;
class WebGLTransformFeedback;
class WebGLUniformLocation;
class WebGLVertexArrayObject;
class WebGL2RenderingContextBase : public WebGLRenderingContextBase {
WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(WebGL2RenderingContextBase);
public:
~WebGL2RenderingContextBase() override;
/* Buffer objects */
void copyBufferSubData(GLenum, GLenum, long long, long long, long long);
void getBufferSubData(GLenum target, long long offset, DOMArrayBuffer* returnedData);
/* Framebuffer objects */
bool validateTexFuncLayer(const char*, GLenum texTarget, GLint layer);
void blitFramebuffer(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum);
void framebufferTextureLayer(ScriptState*, GLenum, GLenum, WebGLTexture*, GLint, GLint);
ScriptValue getInternalformatParameter(ScriptState*, GLenum, GLenum, GLenum);
void invalidateFramebuffer(GLenum, const Vector<GLenum>&);
void invalidateSubFramebuffer(GLenum, const Vector<GLenum>&, GLint, GLint, GLsizei, GLsizei);
void readBuffer(GLenum);
/* Renderbuffer objects */
void renderbufferStorageMultisample(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
/* Texture objects */
void texImage2D(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLintptr);
// Have to re-declair/re-define the following texImage2D functions from base class.
// This is because the above texImage2D() hides the name from base class.
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLsizei width, GLsizei height, GLint border,
GLenum format, GLenum type, DOMArrayBufferView*);
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLenum format, GLenum type, ImageData*);
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLenum format, GLenum type, HTMLImageElement*, ExceptionState&);
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLenum format, GLenum type, HTMLCanvasElement*, ExceptionState&);
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLenum format, GLenum type, HTMLVideoElement*, ExceptionState&);
void texImage2D(GLenum target, GLint level, GLint internalformat,
GLenum format, GLenum type, PassRefPtrWillBeRawPtr<ImageBitmap>, ExceptionState&);
void texStorage2D(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
void texStorage3D(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei);
void texImage3D(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, DOMArrayBufferView*);
void texImage3D(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLintptr);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, DOMArrayBufferView*);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, ImageData*);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, HTMLImageElement*, ExceptionState&);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, HTMLCanvasElement*, ExceptionState&);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, HTMLVideoElement*, ExceptionState&);
void texSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, PassRefPtrWillBeRawPtr<ImageBitmap>, ExceptionState&);
void copyTexSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
void compressedTexImage3D(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, DOMArrayBufferView*);
void compressedTexSubImage3D(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, DOMArrayBufferView*);
/* Programs and shaders */
GLint getFragDataLocation(WebGLProgram*, const String&);
/* Uniforms and attributes */
void uniform1ui(const WebGLUniformLocation*, GLuint);
void uniform2ui(const WebGLUniformLocation*, GLuint, GLuint);
void uniform3ui(const WebGLUniformLocation*, GLuint, GLuint, GLuint);
void uniform4ui(const WebGLUniformLocation*, GLuint, GLuint, GLuint, GLuint);
void uniform1uiv(const WebGLUniformLocation*, const FlexibleUint32ArrayView&);
void uniform1uiv(const WebGLUniformLocation*, Vector<GLuint>&);
void uniform2uiv(const WebGLUniformLocation*, const FlexibleUint32ArrayView&);
void uniform2uiv(const WebGLUniformLocation*, Vector<GLuint>&);
void uniform3uiv(const WebGLUniformLocation*, const FlexibleUint32ArrayView&);
void uniform3uiv(const WebGLUniformLocation*, Vector<GLuint>&);
void uniform4uiv(const WebGLUniformLocation*, const FlexibleUint32ArrayView&);
void uniform4uiv(const WebGLUniformLocation*, Vector<GLuint>&);
void uniformMatrix2x3fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix2x3fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void uniformMatrix3x2fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix3x2fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void uniformMatrix2x4fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix2x4fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void uniformMatrix4x2fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix4x2fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void uniformMatrix3x4fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix3x4fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void uniformMatrix4x3fv(const WebGLUniformLocation*, GLboolean, DOMFloat32Array*);
void uniformMatrix4x3fv(const WebGLUniformLocation*, GLboolean, Vector<GLfloat>&);
void vertexAttribI4i(GLuint, GLint, GLint, GLint, GLint);
void vertexAttribI4iv(GLuint, const DOMInt32Array*);
void vertexAttribI4iv(GLuint, const Vector<GLint>&);
void vertexAttribI4ui(GLuint, GLuint, GLuint, GLuint, GLuint);
void vertexAttribI4uiv(GLuint, const DOMUint32Array*);
void vertexAttribI4uiv(GLuint, const Vector<GLuint>&);
void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, long long offset);
/* Writing to the drawing buffer */
void vertexAttribDivisor(GLuint, GLuint);
void drawArraysInstanced(GLenum, GLint, GLsizei, GLsizei);
void drawElementsInstanced(GLenum, GLsizei, GLenum, long long, GLsizei);
void drawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, long long offset);
/* Multiple Render Targets */
void drawBuffers(const Vector<GLenum>&);
void clearBufferiv(GLenum, GLint, DOMInt32Array*);
void clearBufferiv(GLenum, GLint, const Vector<GLint>&);
void clearBufferuiv(GLenum, GLint, DOMUint32Array*);
void clearBufferuiv(GLenum, GLint, const Vector<GLuint>&);
void clearBufferfv(GLenum, GLint, DOMFloat32Array*);
void clearBufferfv(GLenum, GLint, const Vector<GLfloat>&);
void clearBufferfi(GLenum, GLint, GLfloat, GLint);
/* Query Objects */
WebGLQuery* createQuery();
void deleteQuery(WebGLQuery*);
GLboolean isQuery(WebGLQuery*);
void beginQuery(GLenum, WebGLQuery*);
void endQuery(GLenum);
WebGLQuery* getQuery(GLenum, GLenum);
ScriptValue getQueryParameter(ScriptState*, WebGLQuery*, GLenum);
/* Sampler Objects */
WebGLSampler* createSampler();
void deleteSampler(WebGLSampler*);
GLboolean isSampler(WebGLSampler*);
void bindSampler(GLuint, WebGLSampler*);
void samplerParameteri(WebGLSampler*, GLenum, GLint);
void samplerParameterf(WebGLSampler*, GLenum, GLfloat);
ScriptValue getSamplerParameter(ScriptState*, WebGLSampler*, GLenum);
/* Sync objects */
WebGLSync* fenceSync(GLenum, GLbitfield);
GLboolean isSync(WebGLSync*);
void deleteSync(WebGLSync*);
GLenum clientWaitSync(WebGLSync*, GLbitfield, GLint64);
void waitSync(WebGLSync*, GLbitfield, GLint64);
ScriptValue getSyncParameter(ScriptState*, WebGLSync*, GLenum);
/* Transform Feedback */
WebGLTransformFeedback* createTransformFeedback();
void deleteTransformFeedback(WebGLTransformFeedback*);
GLboolean isTransformFeedback(WebGLTransformFeedback*);
void bindTransformFeedback(GLenum, WebGLTransformFeedback*);
void beginTransformFeedback(GLenum);
void endTransformFeedback();
void transformFeedbackVaryings(WebGLProgram*, const Vector<String>&, GLenum);
WebGLActiveInfo* getTransformFeedbackVarying(WebGLProgram*, GLuint);
void pauseTransformFeedback();
void resumeTransformFeedback();
bool validateTransformFeedbackPrimitiveMode(const char* functionName, GLenum primitiveMode);
/* Uniform Buffer Objects and Transform Feedback Buffers */
void bindBufferBase(GLenum, GLuint, WebGLBuffer*);
void bindBufferRange(GLenum, GLuint, WebGLBuffer*, long long, long long);
ScriptValue getIndexedParameter(ScriptState*, GLenum, GLuint);
Vector<GLuint> getUniformIndices(WebGLProgram*, const Vector<String>&);
ScriptValue getActiveUniforms(ScriptState*, WebGLProgram*, const Vector<GLuint>&, GLenum);
GLuint getUniformBlockIndex(WebGLProgram*, const String&);
ScriptValue getActiveUniformBlockParameter(ScriptState*, WebGLProgram*, GLuint, GLenum);
String getActiveUniformBlockName(WebGLProgram*, GLuint);
void uniformBlockBinding(WebGLProgram*, GLuint, GLuint);
/* Vertex Array Objects */
WebGLVertexArrayObject* createVertexArray();
void deleteVertexArray(ScriptState*, WebGLVertexArrayObject*);
GLboolean isVertexArray(WebGLVertexArrayObject*);
void bindVertexArray(ScriptState*, WebGLVertexArrayObject*);
/* Reading */
void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, long long offset);
/* WebGLRenderingContextBase overrides */
void initializeNewContext() override;
void bindFramebuffer(ScriptState*, GLenum target, WebGLFramebuffer*) override;
void deleteFramebuffer(WebGLFramebuffer*) override;
ScriptValue getParameter(ScriptState*, GLenum pname) override;
ScriptValue getTexParameter(ScriptState*, GLenum target, GLenum pname) override;
ScriptValue getFramebufferAttachmentParameter(ScriptState*, GLenum target, GLenum attachment, GLenum pname) override;
void pixelStorei(GLenum pname, GLint param) override;
void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels) override;
void restoreCurrentFramebuffer() override;
EAGERLY_FINALIZE();
DECLARE_VIRTUAL_TRACE();
protected:
WebGL2RenderingContextBase(HTMLCanvasElement*, PassOwnPtr<WebGraphicsContext3D>, const WebGLContextAttributes& requestedAttributes);
// Helper function to validate target and the attachment combination for getFramebufferAttachmentParameters.
// Generate GL error and return false if parameters are illegal.
bool validateGetFramebufferAttachmentParameterFunc(const char* functionName, GLenum target, GLenum attachment);
bool validateClearBuffer(const char* functionName, GLenum buffer, GLsizei length);
enum TexStorageType {
TexStorageType2D,
TexStorageType3D,
};
bool validateTexStorage(const char*, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, TexStorageType);
bool validateUniformBlockIndex(const char*, WebGLProgram*, GLuint);
ScriptValue getInt64Parameter(ScriptState*, GLenum);
void texSubImage3DImpl(GLenum, GLint, GLint, GLint, GLint, GLenum, GLenum, Image*, WebGLImageConversion::ImageHtmlDomSource, bool, bool);
void samplerParameter(WebGLSampler*, GLenum, GLfloat, GLint, bool);
bool isBufferBoundToTransformFeedback(WebGLBuffer*);
bool isBufferBoundToNonTransformFeedback(WebGLBuffer*);
bool validateBufferTargetCompatibility(const char*, GLenum, WebGLBuffer*);
bool validateBufferBaseTarget(const char* functionName, GLenum target);
bool validateAndUpdateBufferBindBaseTarget(const char* functionName, GLenum, GLuint, WebGLBuffer*);
WebGLImageConversion::PixelStoreParams getPackPixelStoreParams() override;
WebGLImageConversion::PixelStoreParams getUnpackPixelStoreParams() override;
bool checkAndTranslateAttachments(const char* functionName, GLenum, const Vector<GLenum>&, Vector<GLenum>&);
/* WebGLRenderingContextBase overrides */
unsigned getMaxWebGLLocationLength() const override { return 1024; };
bool validateCapability(const char* functionName, GLenum) override;
bool validateBufferTarget(const char* functionName, GLenum target) override;
bool validateAndUpdateBufferBindTarget(const char* functionName, GLenum, WebGLBuffer*) override;
bool validateFramebufferTarget(GLenum target) override;
bool validateReadPixelsFormatAndType(GLenum format, GLenum type, DOMArrayBufferView*) override;
WebGLFramebuffer* getFramebufferBinding(GLenum target) override;
WebGLFramebuffer* getReadFramebufferBinding() override;
GLint getMaxTextureLevelForTarget(GLenum target) override;
void renderbufferStorageImpl(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, const char* functionName) override;
// Helper function to check texture 3D target and texture bound to the target.
// Generate GL errors and return 0 if target is invalid or texture bound is
// null. Otherwise, return the texture bound to the target.
WebGLTexture* validateTexture3DBinding(const char* functionName, GLenum target);
WebGLBuffer* validateBufferDataTarget(const char* functionName, GLenum target) override;
bool validateBufferDataUsage(const char* functionName, GLenum usage) override;
void removeBoundBuffer(WebGLBuffer*) override;
void resetUnpackParameters() override;
void restoreUnpackParameters() override;
bool transformFeedbackActive() const override;
bool transformFeedbackPaused() const override;
void setTransformFeedbackActive(bool);
void setTransformFeedbackPaused(bool);
PersistentWillBeMember<WebGLFramebuffer> m_readFramebufferBinding;
PersistentWillBeMember<WebGLTransformFeedback> m_transformFeedbackBinding;
std::set<GLenum> m_supportedInternalFormatsStorage;
std::set<GLenum> m_compressedTextureFormatsETC2EAC;
PersistentWillBeMember<WebGLBuffer> m_boundCopyReadBuffer;
PersistentWillBeMember<WebGLBuffer> m_boundCopyWriteBuffer;
PersistentWillBeMember<WebGLBuffer> m_boundPixelPackBuffer;
PersistentWillBeMember<WebGLBuffer> m_boundPixelUnpackBuffer;
PersistentWillBeMember<WebGLBuffer> m_boundTransformFeedbackBuffer;
PersistentWillBeMember<WebGLBuffer> m_boundUniformBuffer;
PersistentHeapVectorWillBeHeapVector<Member<WebGLBuffer>> m_boundIndexedTransformFeedbackBuffers;
PersistentHeapVectorWillBeHeapVector<Member<WebGLBuffer>> m_boundIndexedUniformBuffers;
GLint m_maxTransformFeedbackSeparateAttribs;
size_t m_maxBoundUniformBufferIndex;
PersistentWillBeMember<WebGLQuery> m_currentBooleanOcclusionQuery;
PersistentWillBeMember<WebGLQuery> m_currentTransformFeedbackPrimitivesWrittenQuery;
PersistentHeapVectorWillBeHeapVector<Member<WebGLSampler>> m_samplerUnits;
GLint m_packRowLength;
GLint m_packSkipPixels;
GLint m_packSkipRows;
GLint m_unpackRowLength;
GLint m_unpackImageHeight;
GLint m_unpackSkipPixels;
GLint m_unpackSkipRows;
GLint m_unpackSkipImages;
};
DEFINE_TYPE_CASTS(WebGL2RenderingContextBase, CanvasRenderingContext, context,
context->is3d() && WebGLRenderingContextBase::getWebGLVersion(context) >= 2,
context.is3d() && WebGLRenderingContextBase::getWebGLVersion(&context) >= 2);
} // namespace blink
#endif
|
