1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "context/webgl2_rendering_context_base.h"
16
17 #include "context/webgl2_rendering_context.h"
18 #include "napi/n_class.h"
19 #include "napi/n_func_arg.h"
20 #include "util/log.h"
21 #include "util/util.h"
22 #include "webgl/webgl_active_info.h"
23 #include "webgl/webgl_arg.h"
24 #include "webgl/webgl_buffer.h"
25 #include "webgl/webgl_framebuffer.h"
26 #include "webgl/webgl_program.h"
27 #include "webgl/webgl_query.h"
28 #include "webgl/webgl_renderbuffer.h"
29 #include "webgl/webgl_sampler.h"
30 #include "webgl/webgl_shader.h"
31 #include "webgl/webgl_sync.h"
32 #include "webgl/webgl_texture.h"
33 #include "webgl/webgl_transform_feedback.h"
34 #include "webgl/webgl_uniform_location.h"
35 #include "webgl/webgl_vertex_array_object.h"
36
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40 namespace OHOS {
41 namespace Rosen {
42 using namespace std;
GetWebGL2RenderingContext(napi_env env,napi_value thisVar)43 static WebGL2RenderingContext* GetWebGL2RenderingContext(napi_env env, napi_value thisVar)
44 {
45 return reinterpret_cast<WebGL2RenderingContext*>(Util::GetContextObject(env, thisVar));
46 }
47
DrawBuffers(napi_env env,napi_callback_info info)48 napi_value WebGL2RenderingContextBase::DrawBuffers(napi_env env, napi_callback_info info)
49 {
50 NFuncArg funcArg(env, info);
51 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
52 return NVal::CreateNull(env).val_;
53 }
54
55 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
56 return (context == nullptr) ? NVal::CreateNull(env).val_ :
57 context->GetWebGL2RenderingContextImpl().DrawBuffers(env, funcArg[NARG_POS::FIRST]);
58 }
59
ClearBufferfv(napi_env env,napi_callback_info info)60 napi_value WebGL2RenderingContextBase::ClearBufferfv(napi_env env, napi_callback_info info)
61 {
62 NFuncArg funcArg(env, info);
63 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
64 return NVal::CreateNull(env).val_;
65 }
66
67 bool succ = false;
68 GLenum buffer = 0;
69 tie(succ, buffer) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
70 if (!succ) {
71 return NVal::CreateNull(env).val_;
72 }
73 GLint drawbuffer = 0;
74 tie(succ, drawbuffer) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
75 if (!succ) {
76 return NVal::CreateNull(env).val_;
77 }
78 int64_t srcOffset = 0;
79 if (!NVal(env, funcArg[NARG_POS::FOURTH]).IsNull()) {
80 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
81 if (!succ) {
82 return NVal::CreateNull(env).val_;
83 }
84 }
85 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
86 return (context == nullptr) ? NVal::CreateNull(env).val_ :
87 context->GetWebGL2RenderingContextImpl().ClearBufferV(
88 env, buffer, drawbuffer, funcArg[NARG_POS::THIRD], srcOffset, BUFFER_DATA_FLOAT_32);
89 }
90
ClearBufferiv(napi_env env,napi_callback_info info)91 napi_value WebGL2RenderingContextBase::ClearBufferiv(napi_env env, napi_callback_info info)
92 {
93 NFuncArg funcArg(env, info);
94 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
95 return NVal::CreateNull(env).val_;
96 }
97
98 bool succ = false;
99 GLenum buffer = 0;
100 tie(succ, buffer) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
101 if (!succ) {
102 return NVal::CreateNull(env).val_;
103 }
104 GLint drawbuffer = 0;
105 tie(succ, drawbuffer) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
106 if (!succ) {
107 return NVal::CreateNull(env).val_;
108 }
109 int64_t srcOffset = 0;
110 if (funcArg[NARG_POS::FOURTH] != nullptr) {
111 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
112 if (!succ) {
113 return NVal::CreateNull(env).val_;
114 }
115 }
116 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
117 return (context == nullptr) ? NVal::CreateNull(env).val_ :
118 context->GetWebGL2RenderingContextImpl().ClearBufferV(
119 env, buffer, drawbuffer, funcArg[NARG_POS::THIRD], srcOffset, BUFFER_DATA_INT_32);
120 }
121
ClearBufferuiv(napi_env env,napi_callback_info info)122 napi_value WebGL2RenderingContextBase::ClearBufferuiv(napi_env env, napi_callback_info info)
123 {
124 NFuncArg funcArg(env, info);
125 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
126 return NVal::CreateNull(env).val_;
127 }
128
129 bool succ = false;
130 GLenum buffer = 0;
131 tie(succ, buffer) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
132 if (!succ) {
133 return NVal::CreateNull(env).val_;
134 }
135 GLint drawbuffer = 0;
136 tie(succ, drawbuffer) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
137 if (!succ) {
138 return NVal::CreateNull(env).val_;
139 }
140 int64_t srcOffset = 0;
141 if (funcArg[NARG_POS::FOURTH] != nullptr) {
142 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
143 if (!succ) {
144 return NVal::CreateNull(env).val_;
145 }
146 }
147 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
148 return (context == nullptr) ? NVal::CreateNull(env).val_ :
149 context->GetWebGL2RenderingContextImpl().ClearBufferV(
150 env, buffer, drawbuffer, funcArg[NARG_POS::THIRD], srcOffset, BUFFER_DATA_UINT_32);
151 }
152
ClearBufferfi(napi_env env,napi_callback_info info)153 napi_value WebGL2RenderingContextBase::ClearBufferfi(napi_env env, napi_callback_info info)
154 {
155 NFuncArg funcArg(env, info);
156 if (!funcArg.InitArgs(NARG_CNT::FOUR)) {
157 return NVal::CreateNull(env).val_;
158 }
159
160 bool succ = false;
161 GLenum buffer = 0;
162 tie(succ, buffer) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
163 if (!succ) {
164 return NVal::CreateNull(env).val_;
165 }
166 GLint drawbuffer = 0;
167 tie(succ, drawbuffer) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
168 if (!succ) {
169 return NVal::CreateNull(env).val_;
170 }
171 GLfloat depth = 0.0;
172 tie(succ, depth) = NVal(env, funcArg[NARG_POS::THIRD]).ToFloat();
173 if (!succ) {
174 return NVal::CreateNull(env).val_;
175 }
176 GLint stencil = 0;
177 tie(succ, stencil) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
178 if (!succ) {
179 return NVal::CreateNull(env).val_;
180 }
181 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
182 return (context == nullptr) ? NVal::CreateNull(env).val_ :
183 context->GetWebGL2RenderingContextImpl().ClearBufferfi(env, buffer, drawbuffer, depth, stencil);
184 }
185
CreateQuery(napi_env env,napi_callback_info info)186 napi_value WebGL2RenderingContextBase::CreateQuery(napi_env env, napi_callback_info info)
187 {
188 NFuncArg funcArg(env, info);
189 if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
190 return NVal::CreateNull(env).val_;
191 }
192 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
193 return (context == nullptr) ? NVal::CreateNull(env).val_ :
194 context->GetWebGL2RenderingContextImpl().CreateQuery(env);
195 }
196
DeleteQuery(napi_env env,napi_callback_info info)197 napi_value WebGL2RenderingContextBase::DeleteQuery(napi_env env, napi_callback_info info)
198 {
199 NFuncArg funcArg(env, info);
200 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
201 return NVal::CreateNull(env).val_;
202 }
203
204 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
205 return (context == nullptr) ? NVal::CreateNull(env).val_ :
206 context->GetWebGL2RenderingContextImpl().DeleteQuery(env, funcArg[NARG_POS::FIRST]);
207 }
208
IsQuery(napi_env env,napi_callback_info info)209 napi_value WebGL2RenderingContextBase::IsQuery(napi_env env, napi_callback_info info)
210 {
211 NFuncArg funcArg(env, info);
212 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
213 return NVal::CreateBool(env, false).val_;
214 }
215
216 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
217 return (context == nullptr) ? NVal::CreateNull(env).val_ :
218 context->GetWebGL2RenderingContextImpl().IsQuery(env, funcArg[NARG_POS::FIRST]);
219 }
220
BeginQuery(napi_env env,napi_callback_info info)221 napi_value WebGL2RenderingContextBase::BeginQuery(napi_env env, napi_callback_info info)
222 {
223 NFuncArg funcArg(env, info);
224
225 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
226 return NVal::CreateNull(env).val_;
227 }
228 bool succ = false;
229 GLenum target = 0;
230 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
231 if (!succ) {
232 return NVal::CreateNull(env).val_;
233 }
234 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
235 return (context == nullptr) ? NVal::CreateNull(env).val_ :
236 context->GetWebGL2RenderingContextImpl().BeginQuery(env, target, funcArg[NARG_POS::SECOND]);
237 }
238
EndQuery(napi_env env,napi_callback_info info)239 napi_value WebGL2RenderingContextBase::EndQuery(napi_env env, napi_callback_info info)
240 {
241 NFuncArg funcArg(env, info);
242 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
243 return NVal::CreateNull(env).val_;
244 }
245
246 bool succ = false;
247 GLenum target;
248 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
249 if (!succ) {
250 return NVal::CreateNull(env).val_;
251 }
252 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
253 return (context == nullptr) ? NVal::CreateNull(env).val_ :
254 context->GetWebGL2RenderingContextImpl().EndQuery(env, target);
255 }
256
GetQuery(napi_env env,napi_callback_info info)257 napi_value WebGL2RenderingContextBase::GetQuery(napi_env env, napi_callback_info info)
258 {
259 NFuncArg funcArg(env, info);
260 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
261 return NVal::CreateNull(env).val_;
262 }
263 bool succ = false;
264 GLenum target = 0;
265 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
266 if (!succ) {
267 return NVal::CreateNull(env).val_;
268 }
269 GLenum pName = 0;
270 tie(succ, pName) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
271 if (!succ) {
272 return NVal::CreateNull(env).val_;
273 }
274 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
275 return (context == nullptr) ? NVal::CreateNull(env).val_ :
276 context->GetWebGL2RenderingContextImpl().GetQuery(env, target, pName);
277 }
278
GetQueryParameter(napi_env env,napi_callback_info info)279 napi_value WebGL2RenderingContextBase::GetQueryParameter(napi_env env, napi_callback_info info)
280 {
281 NFuncArg funcArg(env, info);
282 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
283 return NVal::CreateNull(env).val_;
284 }
285
286 bool succ = false;
287 GLenum pName = 0;
288 tie(succ, pName) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
289 if (!succ) {
290 return NVal::CreateNull(env).val_;
291 }
292 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
293 return (context == nullptr) ? NVal::CreateNull(env).val_ :
294 context->GetWebGL2RenderingContextImpl().GetQueryParameter(env, funcArg[NARG_POS::FIRST], pName);
295 }
296
CreateSampler(napi_env env,napi_callback_info info)297 napi_value WebGL2RenderingContextBase::CreateSampler(napi_env env, napi_callback_info info)
298 {
299 NFuncArg funcArg(env, info);
300 if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
301 return NVal::CreateNull(env).val_;
302 }
303 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
304 return (context == nullptr) ? NVal::CreateNull(env).val_ :
305 context->GetWebGL2RenderingContextImpl().CreateSampler(env);
306 }
307
DeleteSampler(napi_env env,napi_callback_info info)308 napi_value WebGL2RenderingContextBase::DeleteSampler(napi_env env, napi_callback_info info)
309 {
310 NFuncArg funcArg(env, info);
311 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
312 return NVal::CreateNull(env).val_;
313 }
314
315 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
316 return (context == nullptr) ? NVal::CreateNull(env).val_ :
317 context->GetWebGL2RenderingContextImpl().DeleteSampler(env, funcArg[NARG_POS::FIRST]);
318 }
319
IsSampler(napi_env env,napi_callback_info info)320 napi_value WebGL2RenderingContextBase::IsSampler(napi_env env, napi_callback_info info)
321 {
322 NFuncArg funcArg(env, info);
323 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
324 return NVal::CreateBool(env, false).val_;
325 }
326
327 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
328 return (context == nullptr) ? NVal::CreateBool(env, false).val_ :
329 context->GetWebGL2RenderingContextImpl().IsSampler(env, funcArg[NARG_POS::FIRST]);
330 }
331
BindSampler(napi_env env,napi_callback_info info)332 napi_value WebGL2RenderingContextBase::BindSampler(napi_env env, napi_callback_info info)
333 {
334 NFuncArg funcArg(env, info);
335 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
336 return NVal::CreateNull(env).val_;
337 }
338
339 bool succ = false;
340 GLuint unit = 0;
341 tie(succ, unit) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
342 if (!succ) {
343 return NVal::CreateNull(env).val_;
344 }
345 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
346 return (context == nullptr) ? NVal::CreateNull(env).val_ :
347 context->GetWebGL2RenderingContextImpl().BindSampler(env, unit, funcArg[NARG_POS::SECOND]);
348 }
349
SamplerParameteri(napi_env env,napi_callback_info info)350 napi_value WebGL2RenderingContextBase::SamplerParameteri(napi_env env, napi_callback_info info)
351 {
352 NFuncArg funcArg(env, info);
353 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
354 return NVal::CreateNull(env).val_;
355 }
356
357 bool succ = false;
358 GLenum pName = 0;
359 tie(succ, pName) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
360 if (!succ) {
361 return NVal::CreateNull(env).val_;
362 }
363 GLint param = 0;
364 tie(succ, param) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
365 if (!succ) {
366 return NVal::CreateNull(env).val_;
367 }
368 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
369 return (context == nullptr) ? NVal::CreateNull(env).val_ :
370 context->GetWebGL2RenderingContextImpl().SamplerParameter(
371 env, funcArg[NARG_POS::FIRST], pName, false, static_cast<void*>(¶m));
372 }
373
SamplerParameterf(napi_env env,napi_callback_info info)374 napi_value WebGL2RenderingContextBase::SamplerParameterf(napi_env env, napi_callback_info info)
375 {
376 NFuncArg funcArg(env, info);
377 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
378 return NVal::CreateNull(env).val_;
379 }
380
381 bool succ = false;
382 GLenum pName = 0;
383 tie(succ, pName) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
384 if (!succ) {
385 return NVal::CreateNull(env).val_;
386 }
387 float param = 0;
388 tie(succ, param) = NVal(env, funcArg[NARG_POS::THIRD]).ToFloat();
389 if (!succ) {
390 return NVal::CreateNull(env).val_;
391 }
392 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
393 return (context == nullptr) ? NVal::CreateNull(env).val_ :
394 context->GetWebGL2RenderingContextImpl().SamplerParameter(
395 env, funcArg[NARG_POS::FIRST], pName, true, static_cast<void*>(¶m));
396 }
397
GetSamplerParameter(napi_env env,napi_callback_info info)398 napi_value WebGL2RenderingContextBase::GetSamplerParameter(napi_env env, napi_callback_info info)
399 {
400 NFuncArg funcArg(env, info);
401 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
402 return NVal::CreateNull(env).val_;
403 }
404
405 bool succ = false;
406 GLenum pName = 0;
407 tie(succ, pName) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
408 if (!succ) {
409 return NVal::CreateNull(env).val_;
410 }
411 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
412 return (context == nullptr) ? NVal::CreateNull(env).val_ :
413 context->GetWebGL2RenderingContextImpl().GetSamplerParameter(env, funcArg[NARG_POS::FIRST], pName);
414 }
415
FenceSync(napi_env env,napi_callback_info info)416 napi_value WebGL2RenderingContextBase::FenceSync(napi_env env, napi_callback_info info)
417 {
418 NFuncArg funcArg(env, info);
419 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
420 return NVal::CreateNull(env).val_;
421 }
422
423 bool succ = false;
424 GLenum condition = 0;
425 tie(succ, condition) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
426 if (!succ) {
427 return NVal::CreateNull(env).val_;
428 }
429 int64_t flags = 0;
430 tie(succ, flags) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
431 if (!succ) {
432 return NVal::CreateNull(env).val_;
433 }
434 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
435 return (context == nullptr) ? NVal::CreateNull(env).val_ :
436 context->GetWebGL2RenderingContextImpl().FenceSync(env, condition, static_cast<GLbitfield>(flags));
437 }
438
IsSync(napi_env env,napi_callback_info info)439 napi_value WebGL2RenderingContextBase::IsSync(napi_env env, napi_callback_info info)
440 {
441 NFuncArg funcArg(env, info);
442 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
443 return NVal::CreateBool(env, false).val_;
444 }
445 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
446 return (context == nullptr) ? NVal::CreateBool(env, false).val_ :
447 context->GetWebGL2RenderingContextImpl().IsSync(env, funcArg[NARG_POS::FIRST]);
448 }
449
DeleteSync(napi_env env,napi_callback_info info)450 napi_value WebGL2RenderingContextBase::DeleteSync(napi_env env, napi_callback_info info)
451 {
452 NFuncArg funcArg(env, info);
453 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
454 return NVal::CreateNull(env).val_;
455 }
456
457 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
458 return (context == nullptr) ? NVal::CreateNull(env).val_ :
459 context->GetWebGL2RenderingContextImpl().DeleteSync(env, funcArg[NARG_POS::FIRST]);
460 }
461
ClientWaitSync(napi_env env,napi_callback_info info)462 napi_value WebGL2RenderingContextBase::ClientWaitSync(napi_env env, napi_callback_info info)
463 {
464 NFuncArg funcArg(env, info);
465 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
466 return NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_;
467 }
468
469 bool succ = false;
470 int64_t flags = 0;
471 tie(succ, flags) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
472 if (!succ) {
473 return NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_;
474 }
475 int64_t timeout = 0;
476 tie(succ, timeout) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt64();
477 if (!succ) {
478 return NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_;
479 }
480 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
481 return (context == nullptr) ? NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_ :
482 context->GetWebGL2RenderingContextImpl().ClientWaitSync(
483 env, funcArg[NARG_POS::FIRST], static_cast<GLbitfield>(flags), timeout);
484 }
485
WaitSync(napi_env env,napi_callback_info info)486 napi_value WebGL2RenderingContextBase::WaitSync(napi_env env, napi_callback_info info)
487 {
488 NFuncArg funcArg(env, info);
489 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
490 return NVal::CreateNull(env).val_;
491 }
492
493 bool succ = false;
494 int64_t flags = 0;
495 tie(succ, flags) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
496 if (!succ) {
497 return NVal::CreateNull(env).val_;
498 }
499 int64_t timeout = 0;
500 tie(succ, timeout) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt64();
501 if (!succ) {
502 return NVal::CreateNull(env).val_;
503 }
504 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
505 return (context == nullptr) ? NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_ :
506 context->GetWebGL2RenderingContextImpl().WaitSync(
507 env, funcArg[NARG_POS::FIRST], static_cast<GLbitfield>(flags), timeout);
508 }
509
GetSyncParameter(napi_env env,napi_callback_info info)510 napi_value WebGL2RenderingContextBase::GetSyncParameter(napi_env env, napi_callback_info info)
511 {
512 NFuncArg funcArg(env, info);
513 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
514 return NVal::CreateNull(env).val_;
515 }
516
517 bool succ = false;
518 GLenum pname = 0;
519 tie(succ, pname) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
520 if (!succ) {
521 return NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_;
522 }
523 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
524 return (context == nullptr) ? NVal::CreateInt64(env, WebGL2RenderingContextBase::WAIT_FAILED).val_ :
525 context->GetWebGL2RenderingContextImpl().GetSyncParameter(env, funcArg[NARG_POS::FIRST], pname);
526 }
527
CreateTransformFeedback(napi_env env,napi_callback_info info)528 napi_value WebGL2RenderingContextBase::CreateTransformFeedback(napi_env env, napi_callback_info info)
529 {
530 NFuncArg funcArg(env, info);
531 if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
532 return NVal::CreateNull(env).val_;
533 }
534 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
535 return (context == nullptr) ? NVal::CreateNull(env).val_ :
536 context->GetWebGL2RenderingContextImpl().CreateTransformFeedback(env);
537 }
538
DeleteTransformFeedback(napi_env env,napi_callback_info info)539 napi_value WebGL2RenderingContextBase::DeleteTransformFeedback(napi_env env, napi_callback_info info)
540 {
541 NFuncArg funcArg(env, info);
542 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
543 return NVal::CreateNull(env).val_;
544 }
545 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
546 return (context == nullptr) ? NVal::CreateNull(env).val_ :
547 context->GetWebGL2RenderingContextImpl().DeleteTransformFeedback(env, funcArg[NARG_POS::FIRST]);
548 }
549
IsTransformFeedback(napi_env env,napi_callback_info info)550 napi_value WebGL2RenderingContextBase::IsTransformFeedback(napi_env env, napi_callback_info info)
551 {
552 NFuncArg funcArg(env, info);
553 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
554 return NVal::CreateBool(env, false).val_;
555 }
556
557 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
558 return (context == nullptr) ? NVal::CreateBool(env, false).val_ :
559 context->GetWebGL2RenderingContextImpl().IsTransformFeedback(env, funcArg[NARG_POS::FIRST]);
560 }
561
BindTransformFeedback(napi_env env,napi_callback_info info)562 napi_value WebGL2RenderingContextBase::BindTransformFeedback(napi_env env, napi_callback_info info)
563 {
564 NFuncArg funcArg(env, info);
565 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
566 return NVal::CreateNull(env).val_;
567 }
568
569 bool succ = false;
570 GLenum target = 0;
571 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
572 if (context == nullptr) {
573 return NVal::CreateNull(env).val_;
574 }
575 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
576 if (!succ) {
577 context->GetWebGL2RenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_ENUM);
578 return NVal::CreateNull(env).val_;
579 }
580 return context->GetWebGL2RenderingContextImpl().BindTransformFeedback(env, funcArg[NARG_POS::SECOND], target);
581 }
582
BeginTransformFeedback(napi_env env,napi_callback_info info)583 napi_value WebGL2RenderingContextBase::BeginTransformFeedback(napi_env env, napi_callback_info info)
584 {
585 NFuncArg funcArg(env, info);
586 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
587 return NVal::CreateNull(env).val_;
588 }
589 bool succ = false;
590 GLenum primitiveMode = 0;
591 tie(succ, primitiveMode) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
592 if (!succ) {
593 return NVal::CreateNull(env).val_;
594 }
595 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
596 return (context == nullptr) ? NVal::CreateNull(env).val_ :
597 context->GetWebGL2RenderingContextImpl().BeginTransformFeedback(env, primitiveMode);
598 }
599
EndTransformFeedback(napi_env env,napi_callback_info info)600 napi_value WebGL2RenderingContextBase::EndTransformFeedback(napi_env env, napi_callback_info info)
601 {
602 NFuncArg funcArg(env, info);
603 if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
604 return NVal::CreateNull(env).val_;
605 }
606
607 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
608 return (context == nullptr) ? NVal::CreateNull(env).val_ :
609 context->GetWebGL2RenderingContextImpl().EndTransformFeedback(env);
610 }
611
TexStorage3D(napi_env env,napi_callback_info info)612 napi_value WebGL2RenderingContextBase::TexStorage3D(napi_env env, napi_callback_info info)
613 {
614 NFuncArg funcArg(env, info);
615 if (!funcArg.InitArgs(NARG_CNT::SIX)) {
616 return NVal::CreateNull(env).val_;
617 }
618 bool succ = false;
619 TexStorageArg args = {};
620 tie(succ, args.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
621 if (!succ) {
622 return NVal::CreateNull(env).val_;
623 }
624 tie(succ, args.levels) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
625 if (!succ) {
626 return NVal::CreateNull(env).val_;
627 }
628 tie(succ, args.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
629 if (!succ) {
630 return NVal::CreateNull(env).val_;
631 }
632 tie(succ, args.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
633 if (!succ) {
634 return NVal::CreateNull(env).val_;
635 }
636 tie(succ, args.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
637 if (!succ) {
638 return NVal::CreateNull(env).val_;
639 }
640 tie(succ, args.depth) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
641 if (!succ) {
642 return NVal::CreateNull(env).val_;
643 }
644 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
645 return (context == nullptr) ? NVal::CreateNull(env).val_ :
646 context->GetWebGL2RenderingContextImpl().TexStorage3D(env, args);
647 }
648
TexImage3D(napi_env env,napi_callback_info info)649 napi_value WebGL2RenderingContextBase::TexImage3D(napi_env env, napi_callback_info info)
650 {
651 NFuncArg funcArg(env, info);
652 if (!funcArg.InitArgs(NARG_CNT::TEN, NARG_CNT::ELEVEN)) {
653 return NVal::CreateNull(env).val_;
654 }
655
656 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
657 if (context == nullptr) {
658 return NVal::CreateNull(env).val_;
659 }
660 TexImageArg imgArg = {};
661 bool succ = false;
662 tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
663 if (!succ) {
664 return NVal::CreateNull(env).val_;
665 }
666 tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
667 if (!succ) {
668 return NVal::CreateNull(env).val_;
669 }
670 tie(succ, imgArg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
671 if (!succ) {
672 return NVal::CreateNull(env).val_;
673 }
674 tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
675 if (!succ) {
676 return NVal::CreateNull(env).val_;
677 }
678 tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
679 if (!succ) {
680 return NVal::CreateNull(env).val_;
681 }
682 tie(succ, imgArg.depth) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
683 if (!succ) {
684 return NVal::CreateNull(env).val_;
685 }
686 tie(succ, imgArg.border) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToInt32();
687 if (!succ) {
688 return NVal::CreateNull(env).val_;
689 }
690 tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLenum();
691 if (!succ) {
692 return NVal::CreateNull(env).val_;
693 }
694 tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::NINTH]).ToGLenum();
695 if (!succ) {
696 return NVal::CreateNull(env).val_;
697 }
698 if (NVal(env, funcArg[NARG_POS::TENTH]).TypeIs(napi_number)) {
699 int64_t pboOffset = 0;
700 tie(succ, pboOffset) = NVal(env, funcArg[NARG_POS::TENTH]).ToInt64();
701 if (!succ) {
702 return NVal::CreateNull(env).val_;
703 }
704 return context->GetWebGL2RenderingContextImpl().TexImage3D(env, imgArg, static_cast<GLintptr>(pboOffset));
705 }
706 if (NVal(env, funcArg[NARG_POS::TENTH]).IsBufferArray()) {
707 GLuint srcOffset = 0;
708 if (!NVal(env, funcArg[NARG_POS::ELEVENTH]).IsNull()) {
709 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::ELEVENTH]).ToUint32();
710 if (!succ) {
711 return NVal::CreateNull(env).val_;
712 }
713 }
714 return context->GetWebGL2RenderingContextImpl().TexImage3D(env, imgArg, funcArg[NARG_POS::TENTH], srcOffset);
715 } else {
716 return context->GetWebGL2RenderingContextImpl().TexImage3D(env, imgArg, funcArg[NARG_POS::TENTH]);
717 }
718 }
719
TexSubImage3D(napi_env env,napi_callback_info info)720 napi_value WebGL2RenderingContextBase::TexSubImage3D(napi_env env, napi_callback_info info)
721 {
722 NFuncArg funcArg(env, info);
723 if (!funcArg.InitArgs(NARG_CNT::ELEVEN, NARG_CNT::TWELVE)) {
724 return NVal::CreateNull(env).val_;
725 }
726 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
727 if (context == nullptr) {
728 return NVal::CreateNull(env).val_;
729 }
730 TexSubImage3DArg imgArg = {};
731 bool succ = false;
732 tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
733 if (!succ) {
734 return NVal::CreateNull(env).val_;
735 }
736 tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
737 if (!succ) {
738 return NVal::CreateNull(env).val_;
739 }
740 tie(succ, imgArg.xOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
741 if (!succ) {
742 return NVal::CreateNull(env).val_;
743 }
744 tie(succ, imgArg.yOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
745 if (!succ) {
746 return NVal::CreateNull(env).val_;
747 }
748 tie(succ, imgArg.zOffset) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt32();
749 if (!succ) {
750 return NVal::CreateNull(env).val_;
751 }
752 tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
753 if (!succ) {
754 return NVal::CreateNull(env).val_;
755 }
756 tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToGLsizei();
757 if (!succ) {
758 return NVal::CreateNull(env).val_;
759 }
760 tie(succ, imgArg.depth) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLsizei();
761 if (!succ) {
762 return NVal::CreateNull(env).val_;
763 }
764 tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::NINTH]).ToGLenum();
765 if (!succ) {
766 return NVal::CreateNull(env).val_;
767 }
768 tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::TENTH]).ToGLenum();
769 if (!succ) {
770 return NVal::CreateNull(env).val_;
771 }
772 if (NVal(env, funcArg[NARG_POS::ELEVENTH]).TypeIs(napi_number)) {
773 int64_t pboOffset = 0;
774 tie(succ, pboOffset) = NVal(env, funcArg[NARG_POS::ELEVENTH]).ToInt64();
775 if (!succ) {
776 return NVal::CreateNull(env).val_;
777 }
778 return context->GetWebGL2RenderingContextImpl().TexSubImage3D(env, imgArg, static_cast<GLintptr>(pboOffset));
779 }
780 if (NVal(env, funcArg[NARG_POS::ELEVENTH]).IsBufferArray()) {
781 GLuint srcOffset = 0;
782 if (!NVal(env, funcArg[NARG_POS::TWELVETH]).IsNull()) {
783 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::TWELVETH]).ToUint32();
784 if (!succ) {
785 return NVal::CreateNull(env).val_;
786 }
787 }
788 return context->GetWebGL2RenderingContextImpl().TexSubImage3D(
789 env, imgArg, funcArg[NARG_POS::ELEVENTH], srcOffset);
790 } else {
791 return context->GetWebGL2RenderingContextImpl().TexSubImage3D(env, imgArg, funcArg[NARG_POS::ELEVENTH]);
792 }
793 }
794
CopyTexSubImage3D(napi_env env,napi_callback_info info)795 napi_value WebGL2RenderingContextBase::CopyTexSubImage3D(napi_env env, napi_callback_info info)
796 {
797 NFuncArg funcArg(env, info);
798 if (!funcArg.InitArgs(NARG_CNT::NINE)) {
799 return NVal::CreateNull(env).val_;
800 }
801
802 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
803 if (context == nullptr) {
804 return NVal::CreateNull(env).val_;
805 }
806 CopyTexSubImage3DArg imgArg = {};
807 bool succ = false;
808 tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
809 if (!succ) {
810 return NVal::CreateNull(env).val_;
811 }
812 tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
813 if (!succ) {
814 return NVal::CreateNull(env).val_;
815 }
816 tie(succ, imgArg.xOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
817 if (!succ) {
818 return NVal::CreateNull(env).val_;
819 }
820 tie(succ, imgArg.yOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
821 if (!succ) {
822 return NVal::CreateNull(env).val_;
823 }
824 tie(succ, imgArg.zOffset) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt32();
825 if (!succ) {
826 return NVal::CreateNull(env).val_;
827 }
828 tie(succ, imgArg.x) = NVal(env, funcArg[NARG_POS::SIXTH]).ToInt32();
829 if (!succ) {
830 return NVal::CreateNull(env).val_;
831 }
832 tie(succ, imgArg.y) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToInt32();
833 if (!succ) {
834 return NVal::CreateNull(env).val_;
835 }
836 tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLsizei();
837 if (!succ) {
838 return NVal::CreateNull(env).val_;
839 }
840 tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::NINTH]).ToGLsizei();
841 return !succ ? NVal::CreateNull(env).val_ :
842 context->GetWebGL2RenderingContextImpl().CopyTexSubImage3D(env, imgArg);
843 }
844
CompressedTexImage3D(napi_env env,napi_callback_info info)845 napi_value WebGL2RenderingContextBase::CompressedTexImage3D(napi_env env, napi_callback_info info)
846 {
847 NFuncArg funcArg(env, info);
848 if (!funcArg.InitArgs(NARG_CNT::EIGHT, NARG_CNT::TEN)) {
849 return NVal::CreateNull(env).val_;
850 }
851
852 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
853 if (context == nullptr) {
854 return NVal::CreateNull(env).val_;
855 }
856 TexImageArg imgArg = {};
857 bool succ = false;
858 tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
859 if (!succ) {
860 return NVal::CreateNull(env).val_;
861 }
862 tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
863 if (!succ) {
864 return NVal::CreateNull(env).val_;
865 }
866 tie(succ, imgArg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
867 if (!succ) {
868 return NVal::CreateNull(env).val_;
869 }
870 tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
871 if (!succ) {
872 return NVal::CreateNull(env).val_;
873 }
874 tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
875 if (!succ) {
876 return NVal::CreateNull(env).val_;
877 }
878 tie(succ, imgArg.depth) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
879 if (!succ) {
880 return NVal::CreateNull(env).val_;
881 }
882 tie(succ, imgArg.border) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToInt32();
883 if (!succ) {
884 return NVal::CreateNull(env).val_;
885 }
886 if (NVal(env, funcArg[NARG_POS::EIGHTH]).IsBufferArray()) {
887 uint32_t srcOffset = 0;
888 uint32_t srcLengthOverride = 0;
889 if (!NVal(env, funcArg[NARG_POS::NINTH]).IsNull()) {
890 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::NINTH]).ToUint32();
891 if (!succ) {
892 return NVal::CreateNull(env).val_;
893 }
894 }
895 if (!NVal(env, funcArg[NARG_POS::TENTH]).IsNull()) {
896 tie(succ, srcLengthOverride) = NVal(env, funcArg[NARG_POS::TENTH]).ToUint32();
897 if (!succ) {
898 return NVal::CreateNull(env).val_;
899 }
900 }
901 return context->GetWebGL2RenderingContextImpl().CompressedTexImage3D(
902 env, imgArg, funcArg[NARG_POS::EIGHTH], srcOffset, srcLengthOverride);
903 } else {
904 GLsizei imageSize = 0;
905 tie(succ, imageSize) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLsizei();
906 if (!succ) {
907 return NVal::CreateNull(env).val_;
908 }
909 int64_t srcOffset;
910 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::NINTH]).ToInt64();
911 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().CompressedTexImage3D(
912 env, imgArg, imageSize, static_cast<GLintptr>(srcOffset));
913 }
914 }
915
CompressedTexSubImage3D(napi_env env,napi_callback_info info)916 napi_value WebGL2RenderingContextBase::CompressedTexSubImage3D(napi_env env, napi_callback_info info)
917 {
918 NFuncArg funcArg(env, info);
919 if (!funcArg.InitArgs(NARG_CNT::TEN, NARG_CNT::TWELVE)) {
920 return NVal::CreateNull(env).val_;
921 }
922
923 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
924 if (context == nullptr) {
925 return NVal::CreateNull(env).val_;
926 }
927 TexSubImage3DArg imgArg = {};
928 bool succ = false;
929 tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
930 if (!succ) {
931 return NVal::CreateNull(env).val_;
932 }
933 tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
934 if (!succ) {
935 return NVal::CreateNull(env).val_;
936 }
937 tie(succ, imgArg.xOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
938 if (!succ) {
939 return NVal::CreateNull(env).val_;
940 }
941 tie(succ, imgArg.yOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
942 if (!succ) {
943 return NVal::CreateNull(env).val_;
944 }
945 tie(succ, imgArg.zOffset) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt32();
946 if (!succ) {
947 return NVal::CreateNull(env).val_;
948 }
949 tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
950 if (!succ) {
951 return NVal::CreateNull(env).val_;
952 }
953 tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToGLsizei();
954 if (!succ) {
955 return NVal::CreateNull(env).val_;
956 }
957 tie(succ, imgArg.depth) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLsizei();
958 if (!succ) {
959 return NVal::CreateNull(env).val_;
960 }
961 tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::NINTH]).ToGLenum();
962 if (!succ) {
963 return NVal::CreateNull(env).val_;
964 }
965 if (NVal(env, funcArg[NARG_POS::TENTH]).IsBufferArray()) {
966 uint32_t srcOffset = 0;
967 uint32_t srcLengthOverride = 0;
968 if (!NVal(env, funcArg[NARG_POS::ELEVENTH]).IsNull()) {
969 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::ELEVENTH]).ToUint32();
970 if (!succ) {
971 return NVal::CreateNull(env).val_;
972 }
973 }
974 if (!NVal(env, funcArg[NARG_POS::TWELVETH]).IsNull()) {
975 tie(succ, srcLengthOverride) = NVal(env, funcArg[NARG_POS::TWELVETH]).ToUint32();
976 if (!succ) {
977 return NVal::CreateNull(env).val_;
978 }
979 }
980 return context->GetWebGL2RenderingContextImpl().CompressedTexSubImage3D(
981 env, imgArg, funcArg[NARG_POS::TENTH], srcOffset, srcLengthOverride);
982 } else {
983 GLsizei imageSize = 0;
984 tie(succ, imageSize) = NVal(env, funcArg[NARG_POS::TENTH]).ToGLsizei();
985 if (!succ) {
986 return NVal::CreateNull(env).val_;
987 }
988 int64_t srcOffset;
989 tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::ELEVENTH]).ToInt64();
990 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().CompressedTexSubImage3D(
991 env, imgArg, imageSize, static_cast<GLintptr>(srcOffset));
992 }
993 }
994
GetFragDataLocation(napi_env env,napi_callback_info info)995 napi_value WebGL2RenderingContextBase::GetFragDataLocation(napi_env env, napi_callback_info info)
996 {
997 NFuncArg funcArg(env, info);
998 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
999 return NVal::CreateNull(env).val_;
1000 }
1001
1002 bool succ = false;
1003 unique_ptr<char[]> name = nullptr;
1004 tie(succ, name, ignore) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
1005 if (!succ) {
1006 return NVal::CreateNull(env).val_;
1007 }
1008 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1009 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1010 context->GetWebGL2RenderingContextImpl().GetFragDataLocation(env, funcArg[NARG_POS::FIRST], name.get());
1011 }
1012
Uniform1ui(napi_env env,napi_callback_info info)1013 napi_value WebGL2RenderingContextBase::Uniform1ui(napi_env env, napi_callback_info info)
1014 {
1015 NFuncArg funcArg(env, info);
1016 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1017 return NVal::CreateNull(env).val_;
1018 }
1019
1020 bool succ = false;
1021 const uint32_t count = 1;
1022 GLuint data[4] = {}; // max len 4
1023 for (size_t i = 0; i < count; i++) {
1024 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToUint32();
1025 if (!succ) {
1026 return NVal::CreateNull(env).val_;
1027 }
1028 }
1029 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1030 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1031 context->GetWebGL2RenderingContextImpl().UniformUi(env, funcArg[NARG_POS::FIRST], count, data);
1032 }
1033
Uniform2ui(napi_env env,napi_callback_info info)1034 napi_value WebGL2RenderingContextBase::Uniform2ui(napi_env env, napi_callback_info info)
1035 {
1036 NFuncArg funcArg(env, info);
1037 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
1038 return NVal::CreateNull(env).val_;
1039 }
1040
1041 bool succ = false;
1042 const uint32_t count = 2; // 2 is 2x2
1043 GLuint data[4] = {}; // max len 4
1044 for (size_t i = 0; i < count; i++) {
1045 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToUint32();
1046 if (!succ) {
1047 return NVal::CreateNull(env).val_;
1048 }
1049 }
1050 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1051 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1052 context->GetWebGL2RenderingContextImpl().UniformUi(env, funcArg[NARG_POS::FIRST], count, data);
1053 }
1054
Uniform3ui(napi_env env,napi_callback_info info)1055 napi_value WebGL2RenderingContextBase::Uniform3ui(napi_env env, napi_callback_info info)
1056 {
1057 NFuncArg funcArg(env, info);
1058 if (!funcArg.InitArgs(NARG_CNT::FOUR)) {
1059 return NVal::CreateNull(env).val_;
1060 }
1061
1062 bool succ = false;
1063 const uint32_t count = 3; // 3 is 3x3
1064 GLuint data[4] = {}; // max len 4
1065 for (size_t i = 0; i < count; i++) {
1066 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToUint32();
1067 if (!succ) {
1068 return NVal::CreateNull(env).val_;
1069 }
1070 }
1071 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1072 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1073 context->GetWebGL2RenderingContextImpl().UniformUi(env, funcArg[NARG_POS::FIRST], count, data);
1074 }
1075
Uniform4ui(napi_env env,napi_callback_info info)1076 napi_value WebGL2RenderingContextBase::Uniform4ui(napi_env env, napi_callback_info info)
1077 {
1078 NFuncArg funcArg(env, info);
1079 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1080 return NVal::CreateNull(env).val_;
1081 }
1082
1083 bool succ = false;
1084 const uint32_t count = 4; // 4 is 4x4
1085 GLuint data[4] = {}; // max len 4
1086 for (size_t i = 0; i < count; i++) {
1087 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToUint32();
1088 if (!succ) {
1089 return NVal::CreateNull(env).val_;
1090 }
1091 }
1092 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1093 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1094 context->GetWebGL2RenderingContextImpl().UniformUi(env, funcArg[NARG_POS::FIRST], count, data);
1095 }
1096
VertexAttribI4i(napi_env env,napi_callback_info info)1097 napi_value WebGL2RenderingContextBase::VertexAttribI4i(napi_env env, napi_callback_info info)
1098 {
1099 NFuncArg funcArg(env, info);
1100 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1101 return NVal::CreateNull(env).val_;
1102 }
1103 bool succ = false;
1104 uint32_t index = 0;
1105 tie(succ, index) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
1106 if (!succ) {
1107 return NVal::CreateNull(env).val_;
1108 }
1109
1110 const int32_t count = 4; // 4 max
1111 GLint data[count] = { 0 };
1112 for (int32_t i = 0; i < count; i++) {
1113 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToInt32();
1114 if (!succ) {
1115 return NVal::CreateNull(env).val_;
1116 }
1117 }
1118 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1119 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1120 context->GetWebGL2RenderingContextImpl().VertexAttribI4i(env, index, data);
1121 }
1122
VertexAttribI4ui(napi_env env,napi_callback_info info)1123 napi_value WebGL2RenderingContextBase::VertexAttribI4ui(napi_env env, napi_callback_info info)
1124 {
1125 NFuncArg funcArg(env, info);
1126 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1127 return NVal::CreateNull(env).val_;
1128 }
1129 bool succ = false;
1130 uint32_t index = 0;
1131 tie(succ, index) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
1132 if (!succ) {
1133 return NVal::CreateNull(env).val_;
1134 }
1135
1136 const int32_t count = 4; // 4 max
1137 GLuint data[count] = { 0 };
1138 for (int32_t i = 0; i < count; i++) {
1139 tie(succ, data[i]) = NVal(env, funcArg[i + NARG_POS::SECOND]).ToUint32();
1140 if (!succ) {
1141 return NVal::CreateNull(env).val_;
1142 }
1143 }
1144 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1145 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1146 context->GetWebGL2RenderingContextImpl().VertexAttribI4ui(env, index, data);
1147 }
1148
VertexAttribIPointer(napi_env env,napi_callback_info info)1149 napi_value WebGL2RenderingContextBase::VertexAttribIPointer(napi_env env, napi_callback_info info)
1150 {
1151 NFuncArg funcArg(env, info);
1152 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1153 return NVal::CreateNull(env).val_;
1154 }
1155
1156 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1157 if (context == nullptr) {
1158 return NVal::CreateNull(env).val_;
1159 }
1160 bool succ = false;
1161 VertexAttribArg vertexInfo = { 0 };
1162 tie(succ, vertexInfo.index) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
1163 if (!succ) {
1164 return NVal::CreateNull(env).val_;
1165 }
1166 tie(succ, vertexInfo.size) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
1167 if (!succ) {
1168 return NVal::CreateNull(env).val_;
1169 }
1170 tie(succ, vertexInfo.type) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
1171 if (!succ) {
1172 return NVal::CreateNull(env).val_;
1173 }
1174 tie(succ, vertexInfo.stride) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1175 if (!succ) {
1176 return NVal::CreateNull(env).val_;
1177 }
1178 GLenum result;
1179 tie(result, vertexInfo.offset) = WebGLArg::ToGLintptr(env, funcArg[NARG_POS::FOURTH]);
1180 if (result) {
1181 context->GetWebGL2RenderingContextImpl().SetError(result);
1182 return NVal::CreateNull(env).val_;
1183 }
1184 return context->GetWebGL2RenderingContextImpl().VertexAttribIPointer(env, vertexInfo);
1185 }
1186
VertexAttribDivisor(napi_env env,napi_callback_info info)1187 napi_value WebGL2RenderingContextBase::VertexAttribDivisor(napi_env env, napi_callback_info info)
1188 {
1189 NFuncArg funcArg(env, info);
1190 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1191 return NVal::CreateNull(env).val_;
1192 }
1193
1194 bool succ = false;
1195 int32_t index = 0;
1196 tie(succ, index) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
1197 if (!succ) {
1198 return NVal::CreateNull(env).val_;
1199 }
1200 GLuint divisor;
1201 tie(succ, divisor) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1202 if (!succ) {
1203 return NVal::CreateNull(env).val_;
1204 }
1205 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1206 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1207 context->GetWebGL2RenderingContextImpl().VertexAttribDivisor(env, index, divisor);
1208 }
1209
DrawArraysInstanced(napi_env env,napi_callback_info info)1210 napi_value WebGL2RenderingContextBase::DrawArraysInstanced(napi_env env, napi_callback_info info)
1211 {
1212 NFuncArg funcArg(env, info);
1213 if (!funcArg.InitArgs(NARG_CNT::FOUR)) {
1214 return NVal::CreateNull(env).val_;
1215 }
1216
1217 bool succ = false;
1218 GLenum mode = 0;
1219 tie(succ, mode) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1220 if (!succ) {
1221 return NVal::CreateNull(env).val_;
1222 }
1223 GLint first = 0;
1224 tie(succ, first) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
1225 if (!succ) {
1226 return NVal::CreateNull(env).val_;
1227 }
1228 GLsizei count = 0;
1229 tie(succ, count) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLsizei();
1230 if (!succ) {
1231 return NVal::CreateNull(env).val_;
1232 }
1233 GLsizei instanceCount = 0;
1234 tie(succ, instanceCount) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1235 if (!succ) {
1236 return NVal::CreateNull(env).val_;
1237 }
1238 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1239 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1240 context->GetWebGL2RenderingContextImpl().DrawArraysInstanced(env, mode, first, count, instanceCount);
1241 }
1242
DrawElementsInstanced(napi_env env,napi_callback_info info)1243 napi_value WebGL2RenderingContextBase::DrawElementsInstanced(napi_env env, napi_callback_info info)
1244 {
1245 NFuncArg funcArg(env, info);
1246 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1247 return NVal::CreateNull(env).val_;
1248 }
1249
1250 bool succ = false;
1251 DrawElementArg arg {};
1252 tie(succ, arg.mode) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1253 if (!succ) {
1254 return NVal::CreateNull(env).val_;
1255 }
1256 tie(succ, arg.count) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLsizei();
1257 if (!succ) {
1258 return NVal::CreateNull(env).val_;
1259 }
1260 tie(succ, arg.type) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
1261 if (!succ) {
1262 return NVal::CreateNull(env).val_;
1263 }
1264 tie(succ, arg.offset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
1265 if (!succ) {
1266 return NVal::CreateNull(env).val_;
1267 }
1268 GLsizei instanceCount;
1269 tie(succ, instanceCount) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
1270 if (!succ) {
1271 return NVal::CreateNull(env).val_;
1272 }
1273 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1274 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1275 context->GetWebGL2RenderingContextImpl().DrawElementsInstanced(env, arg, instanceCount);
1276 }
1277
DrawRangeElements(napi_env env,napi_callback_info info)1278 napi_value WebGL2RenderingContextBase::DrawRangeElements(napi_env env, napi_callback_info info)
1279 {
1280 NFuncArg funcArg(env, info);
1281 if (!funcArg.InitArgs(NARG_CNT::SIX)) {
1282 return NVal::CreateNull(env).val_;
1283 }
1284
1285 bool succ = false;
1286 DrawElementArg arg {};
1287 tie(succ, arg.mode) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1288 if (!succ) {
1289 return NVal::CreateNull(env).val_;
1290 }
1291 GLuint start;
1292 tie(succ, start) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1293 if (!succ) {
1294 return NVal::CreateNull(env).val_;
1295 }
1296 GLuint end;
1297 tie(succ, end) = NVal(env, funcArg[NARG_POS::THIRD]).ToUint32();
1298 if (!succ) {
1299 return NVal::CreateNull(env).val_;
1300 }
1301 tie(succ, arg.count) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1302 if (!succ) {
1303 return NVal::CreateNull(env).val_;
1304 }
1305 tie(succ, arg.type) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLenum();
1306 if (!succ) {
1307 return NVal::CreateNull(env).val_;
1308 }
1309 tie(succ, arg.offset) = NVal(env, funcArg[NARG_POS::SIXTH]).ToInt64();
1310 if (!succ) {
1311 return NVal::CreateNull(env).val_;
1312 }
1313 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1314 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1315 context->GetWebGL2RenderingContextImpl().DrawRangeElements(env, arg, start, end);
1316 }
1317
CopyBufferSubData(napi_env env,napi_callback_info info)1318 napi_value WebGL2RenderingContextBase::CopyBufferSubData(napi_env env, napi_callback_info info)
1319 {
1320 NFuncArg funcArg(env, info);
1321 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1322 return NVal::CreateNull(env).val_;
1323 }
1324
1325 bool succ = false;
1326 GLenum targets[2] = {}; // 2 write and read
1327 tie(succ, targets[0]) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum(); // read
1328 if (!succ) {
1329 return NVal::CreateNull(env).val_;
1330 }
1331 tie(succ, targets[1]) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum(); // write
1332 if (!succ) {
1333 return NVal::CreateNull(env).val_;
1334 }
1335 int64_t writeOffset = 0;
1336 int64_t readOffset = 0;
1337 tie(succ, readOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt64(); // read
1338 if (!succ) {
1339 return NVal::CreateNull(env).val_;
1340 }
1341 tie(succ, writeOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64(); // write
1342 if (!succ) {
1343 return NVal::CreateNull(env).val_;
1344 }
1345 int64_t size = 0;
1346 tie(succ, size) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt64();
1347 if (!succ) {
1348 return NVal::CreateNull(env).val_;
1349 }
1350 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1351 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1352 context->GetWebGL2RenderingContextImpl().CopyBufferSubData(env, targets, readOffset, writeOffset, size);
1353 }
1354
GetBufferSubData(napi_env env,napi_callback_info info)1355 napi_value WebGL2RenderingContextBase::GetBufferSubData(napi_env env, napi_callback_info info)
1356 {
1357 NFuncArg funcArg(env, info);
1358 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
1359 return NVal::CreateNull(env).val_;
1360 }
1361
1362 bool succ = false;
1363 BufferExt ext {};
1364 GLenum target = 0;
1365 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1366 if (!succ) {
1367 return NVal::CreateNull(env).val_;
1368 }
1369 int64_t srcByteOffset = 0;
1370 tie(succ, srcByteOffset) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
1371 if (!succ) {
1372 return NVal::CreateNull(env).val_;
1373 }
1374 succ = ext.GetBufferExt(env, funcArg[NARG_POS::FOURTH], funcArg[NARG_POS::FIFTH]);
1375 if (!succ) {
1376 return NVal::CreateNull(env).val_;
1377 }
1378 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1379 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1380 context->GetWebGL2RenderingContextImpl().GetBufferSubData(
1381 env, target, srcByteOffset, funcArg[NARG_POS::THIRD], ext);
1382 }
1383
BlitFramebuffer(napi_env env,napi_callback_info info)1384 napi_value WebGL2RenderingContextBase::BlitFramebuffer(napi_env env, napi_callback_info info)
1385 {
1386 NFuncArg funcArg(env, info);
1387 if (!funcArg.InitArgs(NARG_CNT::TEN)) {
1388 return NVal::CreateNull(env).val_;
1389 }
1390
1391 GLint data[8] = { 0 }; // 8 max data
1392 bool succ = false;
1393 for (int32_t i = 0; i < 8; i++) { // 8 max data
1394 tie(succ, data[i]) = NVal(env, funcArg[i]).ToInt32();
1395 if (!succ) {
1396 return NVal::CreateNull(env).val_;
1397 }
1398 }
1399 int64_t mask = 0;
1400 tie(succ, mask) = NVal(env, funcArg[NARG_POS::NINTH]).ToInt64();
1401 if (!succ) {
1402 return NVal::CreateNull(env).val_;
1403 }
1404 GLenum filter = 0;
1405 tie(succ, filter) = NVal(env, funcArg[NARG_POS::TENTH]).ToGLenum();
1406 if (!succ) {
1407 return NVal::CreateNull(env).val_;
1408 }
1409 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1410 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1411 context->GetWebGL2RenderingContextImpl().BlitFrameBuffer(env, data, static_cast<GLbitfield>(mask), filter);
1412 }
1413
FramebufferTextureLayer(napi_env env,napi_callback_info info)1414 napi_value WebGL2RenderingContextBase::FramebufferTextureLayer(napi_env env, napi_callback_info info)
1415 {
1416 NFuncArg funcArg(env, info);
1417 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1418 return NVal::CreateNull(env).val_;
1419 }
1420
1421 bool succ = false;
1422 TextureLayerArg layer = { 0 };
1423 GLenum target = 0;
1424 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1425 if (!succ) {
1426 return NVal::CreateNull(env).val_;
1427 }
1428 GLenum attachment = 0;
1429 tie(succ, attachment) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
1430 if (!succ) {
1431 return NVal::CreateNull(env).val_;
1432 }
1433 tie(succ, layer.level) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
1434 if (!succ) {
1435 return NVal::CreateNull(env).val_;
1436 }
1437 tie(succ, layer.layer) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt32();
1438 if (!succ) {
1439 return NVal::CreateNull(env).val_;
1440 }
1441 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1442 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1443 context->GetWebGL2RenderingContextImpl().FrameBufferTextureLayer(
1444 env, target, attachment, funcArg[NARG_POS::THIRD], layer);
1445 }
1446
ReadBuffer(napi_env env,napi_callback_info info)1447 napi_value WebGL2RenderingContextBase::ReadBuffer(napi_env env, napi_callback_info info)
1448 {
1449 NFuncArg funcArg(env, info);
1450 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
1451 return NVal::CreateNull(env).val_;
1452 }
1453 bool succ = false;
1454 GLenum src = 0;
1455 tie(succ, src) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1456 if (!succ) {
1457 return NVal::CreateNull(env).val_;
1458 }
1459 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1460 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1461 context->GetWebGL2RenderingContextImpl().ReadBuffer(env, src);
1462 }
1463
RenderbufferStorageMultisample(napi_env env,napi_callback_info info)1464 napi_value WebGL2RenderingContextBase::RenderbufferStorageMultisample(napi_env env, napi_callback_info info)
1465 {
1466 NFuncArg funcArg(env, info);
1467 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1468 return NVal::CreateNull(env).val_;
1469 }
1470
1471 bool succ = false;
1472 TexStorageArg arg = {};
1473 tie(succ, arg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1474 if (!succ) {
1475 return NVal::CreateNull(env).val_;
1476 }
1477 GLsizei samples = 0;
1478 tie(succ, samples) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLsizei();
1479 if (!succ) {
1480 return NVal::CreateNull(env).val_;
1481 }
1482
1483 tie(succ, arg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
1484 if (!succ) {
1485 return NVal::CreateNull(env).val_;
1486 }
1487 tie(succ, arg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1488 if (!succ) {
1489 return NVal::CreateNull(env).val_;
1490 }
1491 tie(succ, arg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
1492 if (!succ) {
1493 return NVal::CreateNull(env).val_;
1494 }
1495 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1496 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1497 context->GetWebGL2RenderingContextImpl().RenderBufferStorageMultiSample(env, arg, samples);
1498 }
1499
RenderbufferStorage(napi_env env,napi_callback_info info)1500 napi_value WebGL2RenderingContextBase::RenderbufferStorage(napi_env env, napi_callback_info info)
1501 {
1502 NFuncArg funcArg(env, info);
1503 if (!funcArg.InitArgs(NARG_CNT::FOUR)) {
1504 return NVal::CreateNull(env).val_;
1505 }
1506 bool succ = false;
1507 TexStorageArg arg = {};
1508 tie(succ, arg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1509 if (!succ) {
1510 return NVal::CreateNull(env).val_;
1511 }
1512 tie(succ, arg.internalFormat) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
1513 if (!succ) {
1514 return NVal::CreateNull(env).val_;
1515 }
1516 tie(succ, arg.width) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLsizei();
1517 if (!succ) {
1518 return NVal::CreateNull(env).val_;
1519 }
1520 tie(succ, arg.height) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1521 if (!succ) {
1522 return NVal::CreateNull(env).val_;
1523 }
1524 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1525 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1526 context->GetWebGL2RenderingContextImpl().RenderBufferStorageMultiSample(env, arg, 0);
1527 }
1528
TexStorage2D(napi_env env,napi_callback_info info)1529 napi_value WebGL2RenderingContextBase::TexStorage2D(napi_env env, napi_callback_info info)
1530 {
1531 NFuncArg funcArg(env, info);
1532 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1533 return NVal::CreateNull(env).val_;
1534 }
1535 bool succ = false;
1536 TexStorageArg arg = {};
1537 arg.depth = 1;
1538 tie(succ, arg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1539 if (!succ) {
1540 return NVal::CreateNull(env).val_;
1541 }
1542 tie(succ, arg.levels) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLsizei();
1543 if (!succ) {
1544 return NVal::CreateNull(env).val_;
1545 }
1546 tie(succ, arg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
1547 if (!succ) {
1548 return NVal::CreateNull(env).val_;
1549 }
1550 tie(succ, arg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
1551 if (!succ) {
1552 return NVal::CreateNull(env).val_;
1553 }
1554 tie(succ, arg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
1555 if (!succ) {
1556 return NVal::CreateNull(env).val_;
1557 }
1558 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1559 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1560 context->GetWebGL2RenderingContextImpl().TexStorage2D(env, arg);
1561 }
1562
GetTransformFeedbackVarying(napi_env env,napi_callback_info info)1563 napi_value WebGL2RenderingContextBase::GetTransformFeedbackVarying(napi_env env, napi_callback_info info)
1564 {
1565 NFuncArg funcArg(env, info);
1566 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1567 return NVal::CreateNull(env).val_;
1568 }
1569
1570 bool succ = false;
1571 GLuint index = 0;
1572 tie(succ, index) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1573 if (!succ) {
1574 return NVal::CreateNull(env).val_;
1575 }
1576
1577 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1578 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1579 context->GetWebGL2RenderingContextImpl().GetTransformFeedbackVarying(env, funcArg[NARG_POS::FIRST], index);
1580 }
1581
PauseTransformFeedback(napi_env env,napi_callback_info info)1582 napi_value WebGL2RenderingContextBase::PauseTransformFeedback(napi_env env, napi_callback_info info)
1583 {
1584 NFuncArg funcArg(env, info);
1585 glPauseTransformFeedback();
1586 return NVal::CreateNull(env).val_;
1587 }
1588
ResumeTransformFeedback(napi_env env,napi_callback_info info)1589 napi_value WebGL2RenderingContextBase::ResumeTransformFeedback(napi_env env, napi_callback_info info)
1590 {
1591 NFuncArg funcArg(env, info);
1592 glResumeTransformFeedback();
1593 return NVal::CreateNull(env).val_;
1594 }
1595
BindBufferBase(napi_env env,napi_callback_info info)1596 napi_value WebGL2RenderingContextBase::BindBufferBase(napi_env env, napi_callback_info info)
1597 {
1598 NFuncArg funcArg(env, info);
1599 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
1600 return NVal::CreateNull(env).val_;
1601 }
1602
1603 bool succ = false;
1604 BufferBaseArg arg { 0 };
1605 tie(succ, arg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1606 if (!succ) {
1607 return NVal::CreateNull(env).val_;
1608 }
1609 tie(succ, arg.index) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1610 if (!succ) {
1611 return NVal::CreateNull(env).val_;
1612 }
1613 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1614 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1615 context->GetWebGL2RenderingContextImpl().BindBufferBase(env, arg, funcArg[NARG_POS::THIRD]);
1616 }
1617
BindBufferRange(napi_env env,napi_callback_info info)1618 napi_value WebGL2RenderingContextBase::BindBufferRange(napi_env env, napi_callback_info info)
1619 {
1620 NFuncArg funcArg(env, info);
1621 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1622 return NVal::CreateNull(env).val_;
1623 }
1624 bool succ = false;
1625 BufferBaseArg arg { 0 };
1626 tie(succ, arg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1627 if (!succ) {
1628 return NVal::CreateNull(env).val_;
1629 }
1630 tie(succ, arg.index) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1631 if (!succ) {
1632 return NVal::CreateNull(env).val_;
1633 }
1634 int64_t offset = 0;
1635 tie(succ, offset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
1636 if (!succ) {
1637 return NVal::CreateNull(env).val_;
1638 }
1639 int64_t size = 0;
1640 tie(succ, size) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt64();
1641 if (!succ) {
1642 return NVal::CreateNull(env).val_;
1643 }
1644
1645 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1646 if (context == nullptr) {
1647 return NVal::CreateNull(env).val_;
1648 }
1649 if (!WebGLArg::CheckNoneNegInt<GLint>(offset) || !WebGLArg::CheckNoneNegInt<GLsizei>(size)) {
1650 context->GetWebGL2RenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_VALUE);
1651 return NVal::CreateNull(env).val_;
1652 }
1653 return context->GetWebGL2RenderingContextImpl().BindBufferRange(
1654 env, arg, funcArg[NARG_POS::THIRD], static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size));
1655 }
1656
GetIndexedParameter(napi_env env,napi_callback_info info)1657 napi_value WebGL2RenderingContextBase::GetIndexedParameter(napi_env env, napi_callback_info info)
1658 {
1659 NFuncArg funcArg(env, info);
1660 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1661 return NVal::CreateNull(env).val_;
1662 }
1663 bool succ = false;
1664 GLenum target = 0;
1665 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
1666 if (!succ) {
1667 return NVal::CreateNull(env).val_;
1668 }
1669 int64_t index = 0;
1670 tie(succ, index) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
1671 if (!succ) {
1672 return NVal::CreateNull(env).val_;
1673 }
1674 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1675 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1676 context->GetWebGL2RenderingContextImpl().GetIndexedParameter(env, target, static_cast<GLuint>(index));
1677 }
1678
GetUniformBlockIndex(napi_env env,napi_callback_info info)1679 napi_value WebGL2RenderingContextBase::GetUniformBlockIndex(napi_env env, napi_callback_info info)
1680 {
1681 NFuncArg funcArg(env, info);
1682 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1683 return NVal::CreateNull(env).val_;
1684 }
1685
1686 bool succ = false;
1687 unique_ptr<char[]> name = nullptr;
1688 tie(succ, name, ignore) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
1689 if (!succ) {
1690 return NVal::CreateNull(env).val_;
1691 }
1692 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1693 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1694 context->GetWebGL2RenderingContextImpl().GetUniformBlockIndex(env, funcArg[NARG_POS::FIRST], name.get());
1695 }
1696
UniformBlockBinding(napi_env env,napi_callback_info info)1697 napi_value WebGL2RenderingContextBase::UniformBlockBinding(napi_env env, napi_callback_info info)
1698 {
1699 NFuncArg funcArg(env, info);
1700 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
1701 return NVal::CreateNull(env).val_;
1702 }
1703
1704 bool succ = false;
1705 GLuint uniformBlockIndex = 0;
1706 tie(succ, uniformBlockIndex) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
1707 if (!succ) {
1708 return NVal::CreateNull(env).val_;
1709 }
1710 GLuint uniformBlockBinding;
1711 tie(succ, uniformBlockBinding) = NVal(env, funcArg[NARG_POS::THIRD]).ToUint32();
1712 if (!succ) {
1713 return NVal::CreateNull(env).val_;
1714 }
1715 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1716 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1717 context->GetWebGL2RenderingContextImpl().UniformBlockBinding(
1718 env, funcArg[NARG_POS::FIRST], uniformBlockIndex, uniformBlockBinding);
1719 }
1720
CreateVertexArray(napi_env env,napi_callback_info info)1721 napi_value WebGL2RenderingContextBase::CreateVertexArray(napi_env env, napi_callback_info info)
1722 {
1723 NFuncArg funcArg(env, info);
1724 if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
1725 return NVal::CreateNull(env).val_;
1726 }
1727
1728 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1729 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1730 context->GetWebGL2RenderingContextImpl().CreateVertexArray(env);
1731 }
1732
DeleteVertexArray(napi_env env,napi_callback_info info)1733 napi_value WebGL2RenderingContextBase::DeleteVertexArray(napi_env env, napi_callback_info info)
1734 {
1735 NFuncArg funcArg(env, info);
1736 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
1737 return NVal::CreateNull(env).val_;
1738 }
1739
1740 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1741 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1742 context->GetWebGL2RenderingContextImpl().DeleteVertexArray(env, funcArg[NARG_POS::FIRST]);
1743 }
1744
IsVertexArray(napi_env env,napi_callback_info info)1745 napi_value WebGL2RenderingContextBase::IsVertexArray(napi_env env, napi_callback_info info)
1746 {
1747 NFuncArg funcArg(env, info);
1748 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
1749 return NVal::CreateBool(env, false).val_;
1750 }
1751
1752 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1753 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1754 context->GetWebGL2RenderingContextImpl().IsVertexArray(env, funcArg[NARG_POS::FIRST]);
1755 }
1756
BindVertexArray(napi_env env,napi_callback_info info)1757 napi_value WebGL2RenderingContextBase::BindVertexArray(napi_env env, napi_callback_info info)
1758 {
1759 NFuncArg funcArg(env, info);
1760 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
1761 return NVal::CreateNull(env).val_;
1762 }
1763
1764 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1765 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1766 context->GetWebGL2RenderingContextImpl().BindVertexArray(env, funcArg[NARG_POS::FIRST]);
1767 }
1768
Uniform1uiv(napi_env env,napi_callback_info info)1769 napi_value WebGL2RenderingContextBase::Uniform1uiv(napi_env env, napi_callback_info info)
1770 {
1771 NFuncArg funcArg(env, info);
1772 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
1773 return NVal::CreateNull(env).val_;
1774 }
1775
1776 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1777 if (context == nullptr) {
1778 return NVal::CreateNull(env).val_;
1779 }
1780 UniformExtInfo extInfo(WebGLArg::UNIFORM_1V_REQUIRE_MIN_SIZE);
1781 bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
1782 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().UniformUiv(
1783 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
1784 }
1785
Uniform2uiv(napi_env env,napi_callback_info info)1786 napi_value WebGL2RenderingContextBase::Uniform2uiv(napi_env env, napi_callback_info info)
1787 {
1788 NFuncArg funcArg(env, info);
1789 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
1790 return NVal::CreateNull(env).val_;
1791 }
1792
1793 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1794 if (context == nullptr) {
1795 return NVal::CreateNull(env).val_;
1796 }
1797 UniformExtInfo extInfo(WebGLArg::UNIFORM_2V_REQUIRE_MIN_SIZE);
1798 bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
1799 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().UniformUiv(
1800 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
1801 }
1802
Uniform3uiv(napi_env env,napi_callback_info info)1803 napi_value WebGL2RenderingContextBase::Uniform3uiv(napi_env env, napi_callback_info info)
1804 {
1805 NFuncArg funcArg(env, info);
1806 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
1807 return NVal::CreateNull(env).val_;
1808 }
1809
1810 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1811 if (context == nullptr) {
1812 return NVal::CreateNull(env).val_;
1813 }
1814 UniformExtInfo extInfo(WebGLArg::UNIFORM_3V_REQUIRE_MIN_SIZE);
1815 bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
1816 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().UniformUiv(
1817 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
1818 }
1819
Uniform4uiv(napi_env env,napi_callback_info info)1820 napi_value WebGL2RenderingContextBase::Uniform4uiv(napi_env env, napi_callback_info info)
1821 {
1822 NFuncArg funcArg(env, info);
1823 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
1824 return NVal::CreateNull(env).val_;
1825 }
1826
1827 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1828 if (context == nullptr) {
1829 return NVal::CreateNull(env).val_;
1830 }
1831 UniformExtInfo extInfo(WebGLArg::UNIFORM_4V_REQUIRE_MIN_SIZE);
1832 bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
1833 return !succ ? NVal::CreateNull(env).val_ : context->GetWebGL2RenderingContextImpl().UniformUiv(
1834 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
1835 }
1836
UniformMatrix3x2fv(napi_env env,napi_callback_info info)1837 napi_value WebGL2RenderingContextBase::UniformMatrix3x2fv(napi_env env, napi_callback_info info)
1838 {
1839 NFuncArg funcArg(env, info);
1840 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
1841 return NVal::CreateNull(env).val_;
1842 }
1843 UniformExtInfo extInfo(WebGLArg::MATRIX_3X2_REQUIRE_MIN_SIZE, 6); // 6 size
1844 bool succ = false;
1845 bool transpose = false;
1846 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1847 if (!succ) {
1848 return NVal::CreateNull(env).val_;
1849 }
1850 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1851 if (!succ) {
1852 return NVal::CreateNull(env).val_;
1853 }
1854 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1855 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1856 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1857 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1858 }
1859
UniformMatrix4x2fv(napi_env env,napi_callback_info info)1860 napi_value WebGL2RenderingContextBase::UniformMatrix4x2fv(napi_env env, napi_callback_info info)
1861 {
1862 NFuncArg funcArg(env, info);
1863 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
1864 return NVal::CreateNull(env).val_;
1865 }
1866
1867 UniformExtInfo extInfo(WebGLArg::MATRIX_4X2_REQUIRE_MIN_SIZE, 8); // 8 size
1868 bool succ = false;
1869 bool transpose = false;
1870 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1871 if (!succ) {
1872 return NVal::CreateNull(env).val_;
1873 }
1874 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1875 if (!succ) {
1876 return NVal::CreateNull(env).val_;
1877 }
1878 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1879 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1880 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1881 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1882 }
1883
UniformMatrix2x3fv(napi_env env,napi_callback_info info)1884 napi_value WebGL2RenderingContextBase::UniformMatrix2x3fv(napi_env env, napi_callback_info info)
1885 {
1886 NFuncArg funcArg(env, info);
1887 if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
1888 return NVal::CreateNull(env).val_;
1889 }
1890
1891 bool succ = false;
1892 bool transpose = false;
1893 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1894 if (!succ) {
1895 return NVal::CreateNull(env).val_;
1896 }
1897 UniformExtInfo extInfo(WebGLArg::MATRIX_2X3_REQUIRE_MIN_SIZE, 6); // 6 size
1898 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1899 if (!succ) {
1900 return NVal::CreateNull(env).val_;
1901 }
1902 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1903 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1904 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1905 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1906 }
1907
UniformMatrix4x3fv(napi_env env,napi_callback_info info)1908 napi_value WebGL2RenderingContextBase::UniformMatrix4x3fv(napi_env env, napi_callback_info info)
1909 {
1910 NFuncArg funcArg(env, info);
1911 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1912 return NVal::CreateNull(env).val_;
1913 }
1914
1915 bool succ = false;
1916 bool transpose = false;
1917 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1918 if (!succ) {
1919 return NVal::CreateNull(env).val_;
1920 }
1921 UniformExtInfo extInfo(WebGLArg::MATRIX_4X3_REQUIRE_MIN_SIZE, 12); // 12 size
1922 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1923 if (!succ) {
1924 return NVal::CreateNull(env).val_;
1925 }
1926 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1927 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1928 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1929 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1930 }
1931
UniformMatrix2x4fv(napi_env env,napi_callback_info info)1932 napi_value WebGL2RenderingContextBase::UniformMatrix2x4fv(napi_env env, napi_callback_info info)
1933 {
1934 NFuncArg funcArg(env, info);
1935 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1936 return NVal::CreateNull(env).val_;
1937 }
1938
1939 bool succ = false;
1940 bool transpose = false;
1941 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1942 if (!succ) {
1943 return NVal::CreateNull(env).val_;
1944 }
1945 UniformExtInfo extInfo(WebGLArg::MATRIX_2X4_REQUIRE_MIN_SIZE, 8); // 8 size
1946 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1947 if (!succ) {
1948 return NVal::CreateNull(env).val_;
1949 }
1950 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1951 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1952 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1953 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1954 }
1955
UniformMatrix3x4fv(napi_env env,napi_callback_info info)1956 napi_value WebGL2RenderingContextBase::UniformMatrix3x4fv(napi_env env, napi_callback_info info)
1957 {
1958 NFuncArg funcArg(env, info);
1959 if (!funcArg.InitArgs(NARG_CNT::FIVE)) {
1960 return NVal::CreateNull(env).val_;
1961 }
1962
1963 bool succ = false;
1964 bool transpose = false;
1965 tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
1966 if (!succ) {
1967 return NVal::CreateNull(env).val_;
1968 }
1969 UniformExtInfo extInfo(WebGLArg::MATRIX_3X4_REQUIRE_MIN_SIZE, 12); // 12 size
1970 succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
1971 if (!succ) {
1972 return NVal::CreateNull(env).val_;
1973 }
1974 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1975 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1976 context->GetWebGL2RenderingContextImpl().UniformMatrixFv(
1977 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
1978 }
1979
VertexAttribI4iv(napi_env env,napi_callback_info info)1980 napi_value WebGL2RenderingContextBase::VertexAttribI4iv(napi_env env, napi_callback_info info)
1981 {
1982 NFuncArg funcArg(env, info);
1983 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
1984 return NVal::CreateNull(env).val_;
1985 }
1986
1987 bool succ = false;
1988 GLuint index = 0;
1989 tie(succ, index) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
1990 if (!succ) {
1991 return NVal::CreateNull(env).val_;
1992 }
1993 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
1994 return (context == nullptr) ? NVal::CreateNull(env).val_ :
1995 context->GetWebGL2RenderingContextImpl().VertexAttribI4iv(env, index, funcArg[NARG_POS::SECOND]);
1996 }
1997
VertexAttribI4uiv(napi_env env,napi_callback_info info)1998 napi_value WebGL2RenderingContextBase::VertexAttribI4uiv(napi_env env, napi_callback_info info)
1999 {
2000 NFuncArg funcArg(env, info);
2001 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2002 return NVal::CreateNull(env).val_;
2003 }
2004
2005 bool succ = false;
2006 GLuint index = 0;
2007 tie(succ, index) = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32();
2008 if (!succ) {
2009 return NVal::CreateNull(env).val_;
2010 }
2011 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2012 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2013 context->GetWebGL2RenderingContextImpl().VertexAttribI4uiv(env, index, funcArg[NARG_POS::SECOND]);
2014 }
2015
InvalidateFramebuffer(napi_env env,napi_callback_info info)2016 napi_value WebGL2RenderingContextBase::InvalidateFramebuffer(napi_env env, napi_callback_info info)
2017 {
2018 NFuncArg funcArg(env, info);
2019 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2020 return NVal::CreateNull(env).val_;
2021 }
2022
2023 bool succ = false;
2024 GLenum target = 0;
2025 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2026 if (!succ) {
2027 return NVal::CreateNull(env).val_;
2028 }
2029 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2030 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2031 context->GetWebGL2RenderingContextImpl().InvalidateFrameBuffer(env, target, funcArg[NARG_POS::SECOND]);
2032 }
2033
InvalidateSubFramebuffer(napi_env env,napi_callback_info info)2034 napi_value WebGL2RenderingContextBase::InvalidateSubFramebuffer(napi_env env, napi_callback_info info)
2035 {
2036 NFuncArg funcArg(env, info);
2037 if (!funcArg.InitArgs(NARG_CNT::SIX)) {
2038 return NVal::CreateNull(env).val_;
2039 }
2040 bool succ = false;
2041 GLenum target = 0;
2042 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2043 if (!succ) {
2044 return NVal::CreateNull(env).val_;
2045 }
2046 BufferPosition position = { 0 };
2047 BufferSize size = { 0 };
2048 tie(succ, position.x) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
2049 if (!succ) {
2050 return NVal::CreateNull(env).val_;
2051 }
2052 tie(succ, position.y) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
2053 if (!succ) {
2054 return NVal::CreateNull(env).val_;
2055 }
2056 tie(succ, size.width) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
2057 if (!succ) {
2058 return NVal::CreateNull(env).val_;
2059 }
2060 tie(succ, size.height) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
2061 if (!succ) {
2062 return NVal::CreateNull(env).val_;
2063 }
2064 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2065 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2066 context->GetWebGL2RenderingContextImpl().InvalidateSubFrameBuffer(
2067 env, target, funcArg[NARG_POS::SECOND], position, size);
2068 }
2069
GetInternalformatParameter(napi_env env,napi_callback_info info)2070 napi_value WebGL2RenderingContextBase::GetInternalformatParameter(napi_env env, napi_callback_info info)
2071 {
2072 NFuncArg funcArg(env, info);
2073 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
2074 return NVal::CreateNull(env).val_;
2075 }
2076
2077 bool succ = false;
2078 GLenum target = 0;
2079 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2080 if (!succ) {
2081 return NVal::CreateNull(env).val_;
2082 }
2083 GLenum internalFormat = 0;
2084 tie(succ, internalFormat) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
2085 if (!succ) {
2086 return NVal::CreateNull(env).val_;
2087 }
2088 GLenum pname = 0;
2089 tie(succ, pname) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
2090 if (!succ) {
2091 return NVal::CreateNull(env).val_;
2092 }
2093 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2094 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2095 context->GetWebGL2RenderingContextImpl().GetInternalFormatParameter(env, target, internalFormat, pname);
2096 }
2097
TransformFeedbackVaryings(napi_env env,napi_callback_info info)2098 napi_value WebGL2RenderingContextBase::TransformFeedbackVaryings(napi_env env, napi_callback_info info)
2099 {
2100 NFuncArg funcArg(env, info);
2101 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
2102 return NVal::CreateNull(env).val_;
2103 }
2104
2105 bool succ = false;
2106 GLenum bufferMode = 0;
2107 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2108 if (context == nullptr) {
2109 return NVal::CreateNull(env).val_;
2110 }
2111 tie(succ, bufferMode) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
2112 if (!succ) {
2113 context->GetWebGL2RenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_ENUM);
2114 return NVal::CreateNull(env).val_;
2115 }
2116 return context->GetWebGL2RenderingContextImpl().TransformFeedbackVaryings(
2117 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], bufferMode);
2118 }
2119
GetUniformIndices(napi_env env,napi_callback_info info)2120 napi_value WebGL2RenderingContextBase::GetUniformIndices(napi_env env, napi_callback_info info)
2121 {
2122 NFuncArg funcArg(env, info);
2123 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2124 return NVal::CreateNull(env).val_;
2125 }
2126
2127 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2128 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2129 context->GetWebGL2RenderingContextImpl().GetUniformIndices(
2130 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND]);
2131 }
2132
GetActiveUniforms(napi_env env,napi_callback_info info)2133 napi_value WebGL2RenderingContextBase::GetActiveUniforms(napi_env env, napi_callback_info info)
2134 {
2135 NFuncArg funcArg(env, info);
2136 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
2137 return NVal::CreateNull(env).val_;
2138 }
2139
2140 bool succ = false;
2141 GLenum pname = 0;
2142 tie(succ, pname) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
2143 if (!succ) {
2144 return NVal::CreateNull(env).val_;
2145 }
2146 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2147 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2148 context->GetWebGL2RenderingContextImpl().GetActiveUniforms(
2149 env, funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], pname);
2150 }
2151
GetActiveUniformBlockParameter(napi_env env,napi_callback_info info)2152 napi_value WebGL2RenderingContextBase::GetActiveUniformBlockParameter(napi_env env, napi_callback_info info)
2153 {
2154 NFuncArg funcArg(env, info);
2155 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
2156 return NVal::CreateNull(env).val_;
2157 }
2158
2159 bool succ = false;
2160 GLuint uniformBlockIndex = 0;
2161 tie(succ, uniformBlockIndex) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
2162 if (!succ) {
2163 return NVal::CreateNull(env).val_;
2164 }
2165 GLenum pname = 0;
2166 tie(succ, pname) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
2167 if (!succ) {
2168 return NVal::CreateNull(env).val_;
2169 }
2170 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2171 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2172 context->GetWebGL2RenderingContextImpl().GetActiveUniformBlockParameter(
2173 env, funcArg[NARG_POS::FIRST], uniformBlockIndex, pname);
2174 }
2175
GetActiveUniformBlockName(napi_env env,napi_callback_info info)2176 napi_value WebGL2RenderingContextBase::GetActiveUniformBlockName(napi_env env, napi_callback_info info)
2177 {
2178 NFuncArg funcArg(env, info);
2179 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2180 return NVal::CreateNull(env).val_;
2181 }
2182
2183 bool succ = false;
2184 GLuint uniformBlockIndex = 0;
2185 tie(succ, uniformBlockIndex) = NVal(env, funcArg[NARG_POS::SECOND]).ToUint32();
2186 if (!succ) {
2187 return NVal::CreateNull(env).val_;
2188 }
2189 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2190 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2191 context->GetWebGL2RenderingContextImpl().GetActiveUniformBlockName(
2192 env, funcArg[NARG_POS::FIRST], uniformBlockIndex);
2193 }
2194
GetParameter(napi_env env,napi_callback_info info)2195 napi_value WebGL2RenderingContextBase::GetParameter(napi_env env, napi_callback_info info)
2196 {
2197 NFuncArg funcArg(env, info);
2198 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
2199 return NVal::CreateNull(env).val_;
2200 }
2201 bool succ = false;
2202 GLenum pname = 0;
2203 tie(succ, pname) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2204 if (!succ) {
2205 return NVal::CreateNull(env).val_;
2206 }
2207 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2208 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2209 context->GetWebGL2RenderingContextImpl().GetParameter(env, pname);
2210 }
2211
GetTexParameter(napi_env env,napi_callback_info info)2212 napi_value WebGL2RenderingContextBase::GetTexParameter(napi_env env, napi_callback_info info)
2213 {
2214 NFuncArg funcArg(env, info);
2215 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2216 return NVal::CreateNull(env).val_;
2217 }
2218 bool succ = false;
2219 GLenum target = 0;
2220 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2221 if (!succ) {
2222 return NVal::CreateNull(env).val_;
2223 }
2224 GLenum pname = 0;
2225 tie(succ, pname) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
2226 if (!succ) {
2227 return NVal::CreateNull(env).val_;
2228 }
2229 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2230 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2231 context->GetWebGL2RenderingContextImpl().GetTexParameter(env, target, pname);
2232 }
2233
GetFramebufferAttachmentParameter(napi_env env,napi_callback_info info)2234 napi_value WebGL2RenderingContextBase::GetFramebufferAttachmentParameter(napi_env env, napi_callback_info info)
2235 {
2236 NFuncArg funcArg(env, info);
2237 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
2238 return NVal::CreateNull(env).val_;
2239 }
2240
2241 bool succ = false;
2242 GLenum target = 0;
2243 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2244 if (!succ) {
2245 return NVal::CreateNull(env).val_;
2246 }
2247 GLenum attachment = 0;
2248 tie(succ, attachment) = NVal(env, funcArg[NARG_POS::SECOND]).ToGLenum();
2249 if (!succ) {
2250 return NVal::CreateNull(env).val_;
2251 }
2252 GLenum pname = 0;
2253 tie(succ, pname) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
2254 if (!succ) {
2255 return NVal::CreateNull(env).val_;
2256 }
2257 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2258 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2259 context->GetWebGL2RenderingContextImpl().GetFrameBufferAttachmentParameter(env, target, attachment, pname);
2260 }
2261
BindBuffer(napi_env env,napi_callback_info info)2262 napi_value WebGL2RenderingContextBase::BindBuffer(napi_env env, napi_callback_info info)
2263 {
2264 NFuncArg funcArg(env, info);
2265
2266 if (!funcArg.InitArgs(NARG_CNT::TWO)) {
2267 return NVal::CreateNull(env).val_;
2268 }
2269 bool succ = false;
2270 GLenum target = 0;
2271 tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
2272 if (!succ) {
2273 return NVal::CreateNull(env).val_;
2274 }
2275 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2276 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2277 context->GetWebGL2RenderingContextImpl().BindBuffer(env, target, funcArg[NARG_POS::SECOND]);
2278 }
DeleteBuffer(napi_env env,napi_callback_info info)2279 napi_value WebGL2RenderingContextBase::DeleteBuffer(napi_env env, napi_callback_info info)
2280 {
2281 NFuncArg funcArg(env, info);
2282 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
2283 return NVal::CreateNull(env).val_;
2284 }
2285
2286 WebGL2RenderingContext* context = GetWebGL2RenderingContext(env, funcArg.GetThisVar());
2287 return (context == nullptr) ? NVal::CreateNull(env).val_ :
2288 context->GetWebGL2RenderingContextImpl().DeleteBuffer(env, funcArg[NARG_POS::FIRST]);
2289 }
2290 } // namespace Rosen
2291 } // namespace OHOS
2292 #ifdef __cplusplus
2293 }
2294 #endif