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 
16 #include "context/webgl_rendering_context_overloads.h"
17 
18 #include <string>
19 #include <vector>
20 
21 #include "context/webgl_rendering_context.h"
22 #include "context/webgl_rendering_context_base_impl.h"
23 #include "napi/n_func_arg.h"
24 #include "util/log.h"
25 #include "util/util.h"
26 #include "webgl/webgl_arg.h"
27 #include "webgl/webgl_buffer.h"
28 #include "webgl/webgl_framebuffer.h"
29 #include "webgl/webgl_program.h"
30 #include "webgl/webgl_renderbuffer.h"
31 #include "webgl/webgl_shader.h"
32 #include "webgl/webgl_texture.h"
33 #include "webgl/webgl_uniform_location.h"
34 
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38 namespace OHOS {
39 namespace Rosen {
40 using namespace std;
GetWebGLRenderingContextBase(napi_env env,napi_value thisVar)41 static WebGLRenderingContext* GetWebGLRenderingContextBase(napi_env env, napi_value thisVar)
42 {
43     return static_cast<WebGLRenderingContext*>(Util::GetContextObject(env, thisVar));
44 }
45 
GetOffset(napi_env env,napi_value data,WebGLRenderingContext * context)46 static int64_t GetOffset(napi_env env, napi_value data, WebGLRenderingContext* context)
47 {
48     if (!NVal(env, data).IsNull()) {
49         int64_t srcOffset = 0;
50         bool succ = false;
51         tie(succ, srcOffset) = NVal(env, data).ToInt64();
52         if (!succ || srcOffset < 0) {
53             context->GetWebGLRenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_VALUE);
54             return -1;
55         }
56     }
57     return 0;
58 }
59 
BufferData(napi_env env,napi_callback_info info)60 napi_value WebGLRenderingContextOverloads::BufferData(napi_env env, napi_callback_info info)
61 {
62     NFuncArg funcArg(env, info);
63     if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
64         return NVal::CreateNull(env).val_;
65     }
66     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
67     if (context == nullptr) {
68         return NVal::CreateNull(env).val_;
69     }
70     bool succ = false;
71     GLenum target = 0;
72     tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
73     if (!succ) {
74         return NVal::CreateNull(env).val_;
75     }
76     GLenum usage = 0;
77     tie(succ, usage) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
78     if (!succ) {
79         return NVal::CreateNull(env).val_;
80     }
81     bool usageSucc = NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number);
82     if (usageSucc) {
83         int64_t size;
84         tie(succ, size) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
85         if (!succ) {
86             return NVal::CreateNull(env).val_;
87         }
88         return context->GetWebGLRenderingContextImpl().BufferData(env, target, size, usage);
89     }
90 
91     BufferExt ext {};
92     if (!context->GetWebGLRenderingContextImpl().IsHighWebGL()) {
93         return context->GetWebGLRenderingContextImpl().BufferData(env, target, funcArg[NARG_POS::SECOND], usage, ext);
94     }
95     succ = ext.GetBufferExt(env, funcArg[NARG_POS::FOURTH], funcArg[NARG_POS::FIFTH]);
96     if (!succ) {
97         context->GetWebGLRenderingContextImpl().SetError(GL_INVALID_VALUE);
98         return NVal::CreateNull(env).val_;
99     }
100     return context->GetWebGLRenderingContextImpl().BufferData(env, target, funcArg[NARG_POS::SECOND], usage, ext);
101 }
102 
BufferSubData(napi_env env,napi_callback_info info)103 napi_value WebGLRenderingContextOverloads::BufferSubData(napi_env env, napi_callback_info info)
104 {
105     NFuncArg funcArg(env, info);
106     if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
107         return NVal::CreateNull(env).val_;
108     }
109 
110     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
111     if (context == nullptr) {
112         return NVal::CreateNull(env).val_;
113     }
114     bool succ = false;
115     GLenum target = 0;
116     tie(succ, target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
117     if (!succ) {
118         return NVal::CreateNull(env).val_;
119     }
120     int64_t offset = 0;
121     tie(succ, offset) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt64();
122     if (!succ) {
123         return NVal::CreateNull(env).val_;
124     }
125     BufferExt ext {};
126     succ = ext.GetBufferExt(env, funcArg[NARG_POS::FOURTH], funcArg[NARG_POS::FIFTH]);
127     if (!succ) {
128         context->GetWebGLRenderingContextImpl().SetError(GL_INVALID_VALUE);
129         return NVal::CreateNull(env).val_;
130     }
131     return context->GetWebGLRenderingContextImpl().BufferSubData(env, target,
132         static_cast<GLintptr>(offset), funcArg[NARG_POS::THIRD], ext);
133 }
134 
CompressedTexImage2D(napi_env env,napi_callback_info info)135 napi_value WebGLRenderingContextOverloads::CompressedTexImage2D(napi_env env, napi_callback_info info)
136 {
137     NFuncArg funcArg(env, info);
138     if (!funcArg.InitArgs(NARG_CNT::SEVEN, NARG_CNT::NINE)) {
139         return NVal::CreateNull(env).val_;
140     }
141 
142     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
143     if (context == nullptr) {
144         return NVal::CreateNull(env).val_;
145     }
146     TexImageArg imgArg = {};
147     imgArg.func = Impl::IMAGE_COMPRESSED_TEX_IMAGE_2D;
148     bool succ = false;
149     tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
150     tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
151     if (!succ) {
152         return NVal::CreateNull(env).val_;
153     }
154     tie(succ, imgArg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLenum();
155     tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
156     if (!succ) {
157         return NVal::CreateNull(env).val_;
158     }
159     tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
160     if (!succ) {
161         return NVal::CreateNull(env).val_;
162     }
163     tie(succ, imgArg.border) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
164     if (!succ) {
165         return NVal::CreateNull(env).val_;
166     }
167     imgArg.format = imgArg.internalFormat;
168     bool usageNumber = NVal(env, funcArg[NARG_POS::SEVENTH]).TypeIs(napi_number);
169     if (context->GetWebGLRenderingContextImpl().IsHighWebGL() && usageNumber) {
170         int64_t imageSize = 0;
171         tie(succ, imageSize) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToInt64();
172         if (!succ) {
173             return NVal::CreateNull(env).val_;
174         }
175         int64_t offset = 0;
176         tie(succ, offset) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToInt64();
177         if (!succ) {
178             return NVal::CreateNull(env).val_;
179         }
180         return context->GetWebGLRenderingContextImpl().CompressedTexImage2D(env,
181             imgArg, static_cast<GLsizei>(imageSize), static_cast<GLintptr>(offset));
182     }
183 
184     GLuint srcOffset = 0;
185     if (funcArg[NARG_POS::EIGHTH] != nullptr) {
186         tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToUint32();
187         if (!succ) {
188             return NVal::CreateNull(env).val_;
189         }
190     }
191     GLuint srcLengthOverride = 0;
192     if (funcArg[NARG_POS::NINTH] != nullptr) {
193         tie(succ, srcLengthOverride) = NVal(env, funcArg[NARG_POS::NINTH]).ToUint32();
194         if (!succ) {
195             return NVal::CreateNull(env).val_;
196         }
197     }
198     return context->GetWebGLRenderingContextImpl().CompressedTexImage2D(env,
199         imgArg, funcArg[NARG_POS::SEVENTH], srcOffset, srcLengthOverride);
200 }
201 
CompressedTexSubImage2D(napi_env env,napi_callback_info info)202 napi_value WebGLRenderingContextOverloads::CompressedTexSubImage2D(napi_env env, napi_callback_info info)
203 {
204     NFuncArg funcArg(env, info);
205     if (!funcArg.InitArgs(NARG_CNT::EIGHT, NARG_CNT::TEN)) {
206         return NVal::CreateNull(env).val_;
207     }
208     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
209     if (context == nullptr) {
210         return NVal::CreateNull(env).val_;
211     }
212 
213     TexSubImage2DArg imgArg = {};
214     imgArg.func = Impl::IMAGE_COMPRESSED_TEX_SUB_IMAGE_2D;
215     bool succ = false;
216     tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
217     tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
218     if (!succ) {
219         return NVal::CreateNull(env).val_;
220     }
221     tie(succ, imgArg.xOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
222     if (!succ) {
223         return NVal::CreateNull(env).val_;
224     }
225     tie(succ, imgArg.yOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
226     if (!succ) {
227         return NVal::CreateNull(env).val_;
228     }
229     tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
230     if (!succ) {
231         return NVal::CreateNull(env).val_;
232     }
233     tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
234     if (!succ) {
235         return NVal::CreateNull(env).val_;
236     }
237     tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToGLenum();
238     imgArg.internalFormat = imgArg.format;
239     bool usageNumber = NVal(env, funcArg[NARG_POS::EIGHTH]).TypeIs(napi_number);
240     if (context->GetWebGLRenderingContextImpl().IsHighWebGL() && usageNumber) {
241         int64_t imageSize = 0;
242         tie(succ, imageSize) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToInt64();
243         if (!succ) {
244             return NVal::CreateNull(env).val_;
245         }
246         int64_t offset = 0;
247         tie(succ, offset) = NVal(env, funcArg[NARG_POS::NINTH]).ToInt64();
248         if (!succ) {
249             return NVal::CreateNull(env).val_;
250         }
251         return context->GetWebGLRenderingContextImpl().CompressedTexSubImage2D(env,
252             imgArg, static_cast<GLsizei>(imageSize), static_cast<GLintptr>(offset));
253     }
254 
255     GLuint srcOffset = 0;
256     if (funcArg[NARG_POS::NINTH] != nullptr) {
257         tie(succ, srcOffset) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToUint32();
258     }
259     GLuint srcLengthOverride = 0;
260     if (funcArg[NARG_POS::TENTH] != nullptr) {
261         tie(succ, srcLengthOverride) = NVal(env, funcArg[NARG_POS::NINTH]).ToUint32();
262     }
263     return context->GetWebGLRenderingContextImpl().CompressedTexSubImage2D(env,
264         imgArg, funcArg[NARG_POS::EIGHTH], srcOffset, srcLengthOverride);
265 }
266 
ReadPixels(napi_env env,napi_callback_info info)267 napi_value WebGLRenderingContextOverloads::ReadPixels(napi_env env, napi_callback_info info)
268 {
269     NFuncArg funcArg(env, info);
270     if (!funcArg.InitArgs(NARG_CNT::SEVEN, NARG_CNT::EIGHT)) {
271         return NVal::CreateNull(env).val_;
272     }
273 
274     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
275     if (context == nullptr) {
276         return NVal::CreateNull(env).val_;
277     }
278     bool succ = false;
279     PixelsArg arg = { 0 };
280     tie(succ, arg.x) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
281     if (!succ) {
282         return NVal::CreateNull(env).val_;
283     }
284     tie(succ, arg.y) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
285     if (!succ) {
286         return NVal::CreateNull(env).val_;
287     }
288     tie(succ, arg.width) = NVal(env, funcArg[NARG_POS::THIRD]).ToGLsizei();
289     if (!succ) {
290         return NVal::CreateNull(env).val_;
291     }
292     tie(succ, arg.height) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLsizei();
293     if (!succ) {
294         return NVal::CreateNull(env).val_;
295     }
296     tie(succ, arg.format) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLenum();
297     if (!succ) {
298         context->GetWebGLRenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_ENUM);
299         return NVal::CreateNull(env).val_;
300     }
301     tie(succ, arg.type) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLenum();
302     if (!succ) {
303         context->GetWebGLRenderingContextImpl().SetError(WebGLRenderingContextBase::INVALID_ENUM);
304         return NVal::CreateNull(env).val_;
305     }
306     if (NVal(env, funcArg[NARG_POS::SEVENTH]).TypeIs(napi_number)) {
307         GLintptr offset;
308         GLenum result;
309         tie(result, offset) = WebGLArg::ToGLintptr(env, funcArg[NARG_POS::SEVENTH]);
310         if (result != 0) {
311             context->GetWebGLRenderingContextImpl().SetError(result);
312             return NVal::CreateNull(env).val_;
313         }
314         return context->GetWebGLRenderingContextImpl().ReadPixels(env, arg, offset);
315     }
316     GLuint dstOffset = 0;
317     if (!NVal(env, funcArg[NARG_POS::EIGHTH]).IsNull()) {
318         tie(succ, dstOffset) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToUint32();
319         if (!succ) {
320             return NVal::CreateNull(env).val_;
321         }
322     }
323     return context->GetWebGLRenderingContextImpl().ReadPixels(env, arg, funcArg[NARG_POS::SEVENTH], dstOffset);
324 }
325 
TexImage2D(napi_env env,napi_callback_info info)326 napi_value WebGLRenderingContextOverloads::TexImage2D(napi_env env, napi_callback_info info)
327 {
328     NFuncArg funcArg(env, info);
329     if (!funcArg.InitArgs(NARG_CNT::SIX, NARG_CNT::TEN)) {
330         return NVal::CreateNull(env).val_;
331     }
332 
333     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
334     if (context == nullptr) {
335         return NVal::CreateNull(env).val_;
336     }
337     TexImageArg imgArg = {};
338     imgArg.func = Impl::IMAGE_TEX_IMAGE_2D;
339     imgArg.depth = 1;
340     bool succ = false;
341     tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
342     if (!succ) {
343         return NVal::CreateNull(env).val_;
344     }
345     tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
346     if (!succ) {
347         return NVal::CreateNull(env).val_;
348     }
349     tie(succ, imgArg.internalFormat) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
350     if (!succ) {
351         return NVal::CreateNull(env).val_;
352     }
353     bool usageNumber = NVal(env, funcArg[NARG_POS::SIXTH]).TypeIs(napi_number);
354     if (!usageNumber) { // for source: TexImageSource
355         tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::FOURTH]).ToGLenum();
356             if (!succ) {
357                 return NVal::CreateNull(env).val_;
358             }
359         tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLenum();
360         return !succ ? nullptr :
361             context->GetWebGLRenderingContextImpl().TexImage2D(env, imgArg, funcArg[NARG_POS::SIXTH]);
362     }
363     tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt64();
364     if (!succ) {
365         return NVal::CreateNull(env).val_;
366     }
367     tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::FIFTH]).ToInt64();
368     if (!succ) {
369         return NVal::CreateNull(env).val_;
370     }
371     tie(succ, imgArg.border) = NVal(env, funcArg[NARG_POS::SIXTH]).ToInt32();
372     if (!succ) {
373         return NVal::CreateNull(env).val_;
374     }
375     tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToGLenum();
376     if (!succ) {
377         return NVal::CreateNull(env).val_;
378     }
379     tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLenum();
380     if (!succ) {
381         return NVal::CreateNull(env).val_;
382     }
383     usageNumber = NVal(env, funcArg[NARG_POS::NINTH]).TypeIs(napi_number);
384     if (context->GetWebGLRenderingContextImpl().IsHighWebGL() && usageNumber) { // support pboOffset
385         int64_t pboOffset = 0;
386         tie(succ, pboOffset) = NVal(env, funcArg[NARG_POS::NINTH]).ToInt64();
387         if (!succ) {
388             return NVal::CreateNull(env).val_;
389         }
390         return context->GetWebGLRenderingContextImpl().TexImage2D(env, imgArg, static_cast<GLintptr>(pboOffset));
391     } else if (NVal(env, funcArg[NARG_POS::NINTH]).IsBufferArray()) {
392         int64_t srcOffset = GetOffset(env, funcArg[NARG_POS::TENTH], context);
393         if (srcOffset < 0) {
394             return NVal::CreateNull(env).val_;
395         }
396         return context->GetWebGLRenderingContextImpl().TexImage2D(
397             env, imgArg, funcArg[NARG_POS::NINTH], static_cast<GLuint>(srcOffset));
398     } else {
399         return context->GetWebGLRenderingContextImpl().TexImage2D(env, imgArg, funcArg[NARG_POS::NINTH]);
400     }
401 }
402 
TexSubImage2D(napi_env env,napi_callback_info info)403 napi_value WebGLRenderingContextOverloads::TexSubImage2D(napi_env env, napi_callback_info info)
404 {
405     NFuncArg funcArg(env, info);
406     if (!(funcArg.InitArgs(NARG_CNT::NINE, NARG_CNT::TEN) || funcArg.InitArgs(NARG_CNT::SEVEN))) {
407         return NVal::CreateNull(env).val_;
408     }
409 
410     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
411     if (context == nullptr) {
412         return NVal::CreateNull(env).val_;
413     }
414     TexSubImage2DArg imgArg = { };
415     imgArg.func = Impl::IMAGE_TEX_SUB_IMAGE_2D;
416     bool succ = false;
417     tie(succ, imgArg.target) = NVal(env, funcArg[NARG_POS::FIRST]).ToGLenum();
418     if (!succ) {
419         return NVal::CreateNull(env).val_;
420     }
421     tie(succ, imgArg.level) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
422     if (!succ) {
423         return NVal::CreateNull(env).val_;
424     }
425     tie(succ, imgArg.xOffset) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
426     if (!succ) {
427         return NVal::CreateNull(env).val_;
428     }
429     tie(succ, imgArg.yOffset) = NVal(env, funcArg[NARG_POS::FOURTH]).ToInt32();
430     if (!succ) {
431         return NVal::CreateNull(env).val_;
432     }
433     bool usageNumber = NVal(env, funcArg[NARG_POS::SEVENTH]).TypeIs(napi_number);
434     if (!usageNumber) {
435         tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLenum();
436         if (!succ) {
437             return NVal::CreateNull(env).val_;
438         }
439         tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLenum();
440         return !succ ? nullptr :
441             context->GetWebGLRenderingContextImpl().TexSubImage2D(env, imgArg, funcArg[NARG_POS::SEVENTH]);
442     }
443 
444     tie(succ, imgArg.width) = NVal(env, funcArg[NARG_POS::FIFTH]).ToGLsizei();
445     if (!succ) {
446         return NVal::CreateNull(env).val_;
447     }
448     tie(succ, imgArg.height) = NVal(env, funcArg[NARG_POS::SIXTH]).ToGLsizei();
449     if (!succ) {
450         return NVal::CreateNull(env).val_;
451     }
452     tie(succ, imgArg.format) = NVal(env, funcArg[NARG_POS::SEVENTH]).ToGLenum();
453     if (!succ) {
454         return NVal::CreateNull(env).val_;
455     }
456     tie(succ, imgArg.type) = NVal(env, funcArg[NARG_POS::EIGHTH]).ToGLenum();
457     if (!succ) {
458         return NVal::CreateNull(env).val_;
459     }
460     usageNumber = NVal(env, funcArg[NARG_POS::NINTH]).TypeIs(napi_number);
461     if (context->GetWebGLRenderingContextImpl().IsHighWebGL() && usageNumber) { // support pboOffset
462         int64_t pboOffset = 0;
463         tie(succ, pboOffset) = NVal(env, funcArg[NARG_POS::NINTH]).ToInt64();
464         if (!succ) {
465             return NVal::CreateNull(env).val_;
466         }
467         return context->GetWebGLRenderingContextImpl().TexSubImage2D(env, imgArg, static_cast<GLintptr>(pboOffset));
468     } else if (NVal(env, funcArg[NARG_POS::NINTH]).IsBufferArray()) { // buffer
469         int64_t srcOffset = GetOffset(env, funcArg[NARG_POS::TENTH], context);
470         if (srcOffset < 0) {
471             return NVal::CreateNull(env).val_;
472         }
473         return context->GetWebGLRenderingContextImpl().TexSubImage2D(env, imgArg, funcArg[NARG_POS::NINTH], 0);
474     } else { // for image source
475         return context->GetWebGLRenderingContextImpl().TexSubImage2D(env, imgArg, funcArg[NARG_POS::NINTH]);
476     }
477 }
478 
Uniform1fv(napi_env env,napi_callback_info info)479 napi_value WebGLRenderingContextOverloads::Uniform1fv(napi_env env, napi_callback_info info)
480 {
481     NFuncArg funcArg(env, info);
482     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
483         return NVal::CreateNull(env).val_;
484     }
485 
486     UniformExtInfo extInfo(1);
487     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
488     if (!succ) {
489         return NVal::CreateNull(env).val_;
490     }
491     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
492     return (context == nullptr) ? nullptr : context->GetWebGLRenderingContextImpl().UniformFv(env,
493         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
494 }
495 
Uniform2fv(napi_env env,napi_callback_info info)496 napi_value WebGLRenderingContextOverloads::Uniform2fv(napi_env env, napi_callback_info info)
497 {
498     NFuncArg funcArg(env, info);
499     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
500         return NVal::CreateNull(env).val_;
501     }
502 
503     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
504     if (context == nullptr) {
505         return NVal::CreateNull(env).val_;
506     }
507     UniformExtInfo extInfo(WebGLArg::UNIFORM_2V_REQUIRE_MIN_SIZE);
508     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
509     if (!succ) {
510         return NVal::CreateNull(env).val_;
511     }
512     return context->GetWebGLRenderingContextImpl().UniformFv(env,
513         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
514 }
515 
Uniform3fv(napi_env env,napi_callback_info info)516 napi_value WebGLRenderingContextOverloads::Uniform3fv(napi_env env, napi_callback_info info)
517 {
518     NFuncArg funcArg(env, info);
519     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
520         return NVal::CreateNull(env).val_;
521     }
522 
523     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
524     if (context == nullptr) {
525         return NVal::CreateNull(env).val_;
526     }
527     UniformExtInfo extInfo(WebGLArg::UNIFORM_3V_REQUIRE_MIN_SIZE);
528     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
529     if (!succ) {
530         return NVal::CreateNull(env).val_;
531     }
532     return context->GetWebGLRenderingContextImpl().UniformFv(env,
533         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
534 }
535 
Uniform4fv(napi_env env,napi_callback_info info)536 napi_value WebGLRenderingContextOverloads::Uniform4fv(napi_env env, napi_callback_info info)
537 {
538     NFuncArg funcArg(env, info);
539     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
540         return NVal::CreateNull(env).val_;
541     }
542 
543     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
544     if (context == nullptr) {
545         return NVal::CreateNull(env).val_;
546     }
547     UniformExtInfo extInfo(WebGLArg::UNIFORM_4V_REQUIRE_MIN_SIZE);
548     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
549     if (!succ) {
550         return NVal::CreateNull(env).val_;
551     }
552     return context->GetWebGLRenderingContextImpl().UniformFv(env,
553         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
554 }
555 
Uniform1iv(napi_env env,napi_callback_info info)556 napi_value WebGLRenderingContextOverloads::Uniform1iv(napi_env env, napi_callback_info info)
557 {
558     NFuncArg funcArg(env, info);
559     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
560         return NVal::CreateNull(env).val_;
561     }
562 
563     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
564     if (context == nullptr) {
565         return NVal::CreateNull(env).val_;
566     }
567     UniformExtInfo extInfo(1);
568     extInfo.dimension = 1;
569     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
570     if (!succ) {
571         return NVal::CreateNull(env).val_;
572     }
573     return context->GetWebGLRenderingContextImpl().UniformIv(env,
574         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
575 }
576 
Uniform2iv(napi_env env,napi_callback_info info)577 napi_value WebGLRenderingContextOverloads::Uniform2iv(napi_env env, napi_callback_info info)
578 {
579     NFuncArg funcArg(env, info);
580     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
581         return NVal::CreateNull(env).val_;
582     }
583 
584     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
585     if (context == nullptr) {
586         return NVal::CreateNull(env).val_;
587     }
588     UniformExtInfo extInfo(WebGLArg::UNIFORM_2V_REQUIRE_MIN_SIZE);
589     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
590     if (!succ) {
591         return NVal::CreateNull(env).val_;
592     }
593     return context->GetWebGLRenderingContextImpl().UniformIv(env,
594         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
595 }
596 
Uniform3iv(napi_env env,napi_callback_info info)597 napi_value WebGLRenderingContextOverloads::Uniform3iv(napi_env env, napi_callback_info info)
598 {
599     NFuncArg funcArg(env, info);
600     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
601         return NVal::CreateNull(env).val_;
602     }
603 
604     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
605     if (context == nullptr) {
606         return NVal::CreateNull(env).val_;
607     }
608     UniformExtInfo extInfo(WebGLArg::UNIFORM_3V_REQUIRE_MIN_SIZE);
609     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
610     if (!succ) {
611         return NVal::CreateNull(env).val_;
612     }
613     return context->GetWebGLRenderingContextImpl().UniformIv(env,
614         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
615 }
616 
Uniform4iv(napi_env env,napi_callback_info info)617 napi_value WebGLRenderingContextOverloads::Uniform4iv(napi_env env, napi_callback_info info)
618 {
619     NFuncArg funcArg(env, info);
620     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
621         return NVal::CreateNull(env).val_;
622     }
623 
624     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
625     if (context == nullptr) {
626         return NVal::CreateNull(env).val_;
627     }
628     UniformExtInfo extInfo(WebGLArg::UNIFORM_4V_REQUIRE_MIN_SIZE);
629     bool succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::THIRD);
630     if (!succ) {
631         return NVal::CreateNull(env).val_;
632     }
633     return context->GetWebGLRenderingContextImpl().UniformIv(env,
634         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::SECOND], &extInfo);
635 }
636 
UniformMatrix2fv(napi_env env,napi_callback_info info)637 napi_value WebGLRenderingContextOverloads::UniformMatrix2fv(napi_env env, napi_callback_info info)
638 {
639     NFuncArg funcArg(env, info);
640     if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
641         return NVal::CreateNull(env).val_;
642     }
643     UniformExtInfo extInfo(WebGLArg::MATRIX_2X2_REQUIRE_MIN_SIZE);
644     bool succ = false;
645     bool transpose = false;
646     tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
647     if (!succ) {
648         return NVal::CreateNull(env).val_;
649     }
650     succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
651     if (!succ) {
652         return NVal::CreateNull(env).val_;
653     }
654     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
655     return (context == nullptr) ? nullptr : context->GetWebGLRenderingContextImpl().UniformMatrixFv(env,
656         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
657 }
658 
UniformMatrix3fv(napi_env env,napi_callback_info info)659 napi_value WebGLRenderingContextOverloads::UniformMatrix3fv(napi_env env, napi_callback_info info)
660 {
661     NFuncArg funcArg(env, info);
662     if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
663         return NVal::CreateNull(env).val_;
664     }
665     UniformExtInfo extInfo(WebGLArg::MATRIX_3X3_REQUIRE_MIN_SIZE);
666     bool succ = false;
667     bool transpose = false;
668     tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
669     if (!succ) {
670         return NVal::CreateNull(env).val_;
671     }
672     succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
673     if (!succ) {
674         return NVal::CreateNull(env).val_;
675     }
676     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
677     return (context == nullptr) ? nullptr : context->GetWebGLRenderingContextImpl().UniformMatrixFv(env,
678         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
679 }
680 
UniformMatrix4fv(napi_env env,napi_callback_info info)681 napi_value WebGLRenderingContextOverloads::UniformMatrix4fv(napi_env env, napi_callback_info info)
682 {
683     NFuncArg funcArg(env, info);
684     if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FIVE)) {
685         return NVal::CreateNull(env).val_;
686     }
687 
688     UniformExtInfo extInfo(WebGLArg::MATRIX_4X4_REQUIRE_MIN_SIZE);
689     bool succ = false;
690     bool transpose = false;
691     tie(succ, transpose) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool();
692     if (!succ) {
693         return NVal::CreateNull(env).val_;
694     }
695     succ = extInfo.GetUniformExtInfo(env, funcArg, NARG_POS::FOURTH);
696     if (!succ) {
697         return NVal::CreateNull(env).val_;
698     }
699     WebGLRenderingContext* context = GetWebGLRenderingContextBase(env, funcArg.GetThisVar());
700     return (context == nullptr) ? nullptr : context->GetWebGLRenderingContextImpl().UniformMatrixFv(env,
701         funcArg[NARG_POS::FIRST], funcArg[NARG_POS::THIRD], transpose, &extInfo);
702 }
703 } // namespace Rosen
704 } // namespace OHOS
705 
706 #ifdef __cplusplus
707 }
708 #endif