@nativescript/canvas 2.0.0-alpha.5 → 2.0.0-alpha.50

package/platforms/ios/src/cpp/webgl2/WebGL2RenderingContext.h

@@ -6,18 +6,13 @@
 #pragma process_pending_includes
 
 #include <vector>
-#include "rust/cxx.h"
 
-#include "canvas2d/CanvasRenderingContext2DImpl.h"
+#include "CanvasRenderingContext2DImpl.h"
 #include "RafImpl.h"
-
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-#include "VecMutableBuffer.h"
 #include <cmath>
 #include "Helpers.h"
-#include "webgl/WebGLRenderingContextBase.h"
-#include "webgl/WebGLRenderingContext.h"
+#include "WebGLRenderingContextBase.h"
+#include "WebGLRenderingContext.h"
 #include "WebGLQuery.h"
 #include "WebGLSampler.h"
 #include "WebGLSyncImpl.h"
@@ -26,406 +21,1496 @@
 #include "gl.h"
 
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT WebGL2RenderingContext : public WebGLRenderingContext {
+class WebGL2RenderingContext : public WebGLRenderingContext {
 public:
 
-    WebGL2RenderingContext(rust::Box<WebGLState> state);
+    WebGL2RenderingContext(WebGLState *state);
+
+    WebGL2RenderingContext(WebGLState *state, WebGLRenderingVersion version);
+
+    static v8::CFunction fast_begin_query_;
+    static v8::CFunction fast_begin_transform_feedback_;
+    static v8::CFunction fast_bind_vertex_array_;
+    static v8::CFunction fast_bind_buffer_base_;
+    static v8::CFunction fast_bind_buffer_range_;
+    static v8::CFunction fast_bind_sampler_;
+    static v8::CFunction fast_bind_transform_feedback_;
+    static v8::CFunction fast_blit_framebuffer_;
+    static v8::CFunction fast_clear_buffer_fi_;
+    static v8::CFunction fast_clear_buffer_fv_;
+    static v8::CFunction fast_clear_buffer_fv_array_;
+    static v8::CFunction fast_clear_buffer_iv_;
+    static v8::CFunction fast_clear_buffer_iv_array_;
+    static v8::CFunction fast_clear_buffer_uiv_;
+    static v8::CFunction fast_clear_buffer_uiv_array_;
+    static v8::CFunction fast_draw_arrays_instanced_;
+    static v8::CFunction fast_draw_buffers_;
+    static v8::CFunction fast_draw_elements_instanced_;
+    static v8::CFunction fast_draw_range_elements_;
+    static v8::CFunction fast_resume_transform_feedback_;
+    static v8::CFunction fast_sampler_parameterf_;
+    static v8::CFunction fast_sampler_parameteri_;
+    static v8::CFunction fast_uniform_1ui_;
+    static v8::CFunction fast_uniform_1uiv_;
+    static v8::CFunction fast_uniform_2ui_;
+    static v8::CFunction fast_uniform_2uiv_;
+    static v8::CFunction fast_uniform_3ui_;
+    static v8::CFunction fast_uniform_3uiv_;
+    static v8::CFunction fast_uniform_4ui_;
+    static v8::CFunction fast_uniform_4uiv_;
+    static v8::CFunction fast_uniform_matrix_2x3fv_;
+    static v8::CFunction fast_uniform_matrix_2x3fv_array_;
+    static v8::CFunction fast_uniform_matrix_2x4fv_;
+    static v8::CFunction fast_uniform_matrix_2x4fv_array_;
+    static v8::CFunction fast_uniform_matrix_3x2fv_;
+    static v8::CFunction fast_uniform_matrix_3x2fv_array_;
+    static v8::CFunction fast_uniform_matrix_3x4fv_;
+    static v8::CFunction fast_uniform_matrix_3x4fv_array_;
+    static v8::CFunction fast_uniform_matrix_4x2fv_;
+    static v8::CFunction fast_uniform_matrix_4x2fv_array_;
+    static v8::CFunction fast_uniform_matrix_4x3fv_;
+    static v8::CFunction fast_uniform_matrix_4x3fv_array_;
+    static v8::CFunction fast_vertex_attrib_divisor_;
+    static v8::CFunction fast_vertex_attrib_i_4i_;
+    static v8::CFunction fast_vertex_attrib_i_4iv_;
+    static v8::CFunction fast_vertex_attrib_i_4iv_array_;
+    static v8::CFunction fast_vertex_attrib_i_4ui_;
+    static v8::CFunction fast_vertex_attrib_i_4uiv_;
+    static v8::CFunction fast_vertex_attrib_i_4uiv_array_;
+    static v8::CFunction fast_uniform_block_binding_;
+
+    static v8::CFunction fast_invalidate_framebuffer_;
+    static v8::CFunction fast_invalidate_sub_framebuffer_;
+
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGL2RenderingContext *renderingContext) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGL2RenderingContext::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::WebGLRenderingContextBase);
+        object->SetAlignedPointerInInternalField(0, renderingContext);
+        renderingContext->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGL2RenderingContext *GetPointer(const v8::Local<v8::Object> &object);
+
+    static void SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void
+    SetProps(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &webgl2RenderingContextTpl);
+
+    static void SetMethods(v8::Isolate *isolate,
+                           const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void BeginQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastBeginQuery(v8::Local<v8::Object> receiver_obj, uint32_t target,
+                               v8::Local<v8::Object> query_obj) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(query_obj);
+        if (type == NativeType::WebGLQuery) {
+            auto query = WebGLQuery::GetPointer(query_obj);
+
+            if (query != nullptr) {
+                canvas_native_webgl2_begin_query(
+                        target,
+                        query->GetQuery(),
+                        ptr->GetState()
+                );
+            }
+        }
+    }
+
+    static void BeginTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastBeginTransformFeedback(v8::Local<v8::Object> receiver_obj, uint32_t value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_webgl2_begin_transform_feedback(
+                value,
+                ptr->GetState()
+        );
+    }
+
+    static void BindBufferBase(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastBindBufferBase(v8::Local<v8::Object> receiver_obj, uint32_t target, uint32_t index,
+                       v8::Local<v8::Object> buffer_obj) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(buffer_obj);
+
+        if (type == NativeType::WebGLBuffer) {
+            auto buffer = WebGLBuffer::GetPointer(buffer_obj);
+
+            canvas_native_webgl2_bind_buffer_base(
+                    target,
+                    index,
+                    buffer->GetBuffer(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void BindBufferRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastBindBufferRange(v8::Local<v8::Object> receiver_obj, uint32_t target, uint32_t index,
+                        v8::Local<v8::Object> buffer_obj, int32_t offset, int32_t size) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(buffer_obj);
+        if (type == NativeType::WebGLBuffer) {
+            auto buffer = WebGLBuffer::GetPointer(buffer_obj);
+            canvas_native_webgl2_bind_buffer_range(
+                    target,
+                    index,
+                    buffer->GetBuffer(),
+                    static_cast<ssize_t>(offset),
+                    static_cast<ssize_t>(size),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void BindSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastBindSampler(v8::Local<v8::Object> receiver_obj, uint32_t unit,
+                                v8::Local<v8::Object> sampler_obj) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(sampler_obj);
+        if (type == NativeType::WebGLSampler) {
+            auto sampler = WebGLSampler::GetPointer(sampler_obj);
+
+            canvas_native_webgl2_bind_sampler(
+                    unit,
+                    sampler->GetSampler(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void BindTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastBindTransformFeedback(v8::Local<v8::Object> receiver_obj, uint32_t target,
+                                          v8::Local<v8::Object> transformer_obj) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(transformer_obj);
+
+        if (type == NativeType::WebGLTransformFeedback) {
+            auto transformFeedback = WebGLTransformFeedback::GetPointer(transformer_obj);
+
+            canvas_native_webgl2_bind_transform_feedback(
+                    target,
+                    transformFeedback->GetFeedback(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void BindVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    BindVertexArrayImpl(WebGL2RenderingContext *ptr, uint32_t vertex_array) {
+        canvas_native_webgl2_bind_vertex_array(
+                vertex_array,
+                ptr->GetState()
+        );
+
+    }
+
+    static void FastBindVertexArray(v8::Local<v8::Object> receiver_obj, uint32_t vertex_array) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        BindVertexArrayImpl(
+                ptr,
+                vertex_array
+        );
+    }
+
+    static void BlitFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastBlitFramebuffer(v8::Local<v8::Object> receiver_obj, int32_t srcX0, int32_t srcY0,
+                        int32_t srcX1, int32_t srcY1, int32_t dstX0, int32_t dstY0, int32_t dstX1,
+                        int32_t dstY1, uint32_t mask, uint32_t filter) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_blit_framebuffer(
+                srcX0,
+                srcY0,
+                srcX1,
+                srcY1,
+                dstX0,
+                dstY0,
+                dstX1,
+                dstY1,
+                mask,
+                filter,
+                ptr->GetState()
+        );
+    }
+
+    static void ClearBufferfi(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastClearBufferfi(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                      double depth, int32_t stencil) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_clear_bufferfi(
+                buffer,
+                drawbuffer,
+                static_cast<float>(depth),
+                stencil,
+                ptr->GetState()
+        );
+    }
+
+    static void ClearBufferfv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastClearBufferfv(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                      const v8::FastApiTypedArray<float> &values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto size = values.length();
+        float *data;
+        values.getStorageIfAligned(&data);
+
+
+        canvas_native_webgl2_clear_bufferfv(
+                buffer,
+                drawbuffer,
+                data,
+                size,
+                ptr->GetState()
+        );
+    }
+
+    static void
+    FastClearBufferfvArray(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                           v8::Local<v8::Array> values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = values->Length();
+        std::vector<float> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                values, buf.data(), len);
+
+
+        if (copied) {
+            canvas_native_webgl2_clear_bufferfv(
+                    buffer,
+                    drawbuffer,
+                    buf.data(),
+                    buf.size(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void ClearBufferiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastClearBufferiv(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                      const v8::FastApiTypedArray<int32_t> &values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto size = values.length();
+        int32_t *data;
+        values.getStorageIfAligned(&data);
+
+
+        canvas_native_webgl2_clear_bufferiv(
+                buffer,
+                drawbuffer,
+                data,
+                size,
+                ptr->GetState()
+        );
+    }
+
+    static void
+    FastClearBufferivArray(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                           v8::Local<v8::Array> values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = values->Length();
+        std::vector<int32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<int32_t>::Build().GetId(), int32_t>(
+                values, buf.data(), len);
+
+
+        if (copied) {
+            canvas_native_webgl2_clear_bufferiv(
+                    buffer,
+                    drawbuffer,
+                    buf.data(),
+                    buf.size(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+
+    static void ClearBufferuiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void
+    FastClearBufferuiv(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                       const v8::FastApiTypedArray<uint32_t> &values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto size = values.length();
+        uint32_t *data;
+        values.getStorageIfAligned(&data);
+
+
+        canvas_native_webgl2_clear_bufferuiv(
+                buffer,
+                drawbuffer,
+                data,
+                size,
+                ptr->GetState()
+        );
+    }
+
+    static void
+    FastClearBufferuivArray(v8::Local<v8::Object> receiver_obj, uint32_t buffer, int32_t drawbuffer,
+                            v8::Local<v8::Array> values) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = values->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                values, buf.data(), len);
+
+
+        if (copied) {
+            canvas_native_webgl2_clear_bufferuiv(
+                    buffer,
+                    drawbuffer,
+                    buf.data(),
+                    buf.size(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+    static void ClientWaitSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawArraysInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastDrawArraysInstanced(v8::Local<v8::Object> receiver_obj, uint32_t mode, int32_t first,
+                            int32_t count, int32_t instanceCount) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_draw_arrays_instanced(
+                mode,
+                first,
+                count,
+                instanceCount,
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+
+    static void DrawBuffers(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastDrawBuffers(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Array> buffers) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = buffers->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                buffers, buf.data(), len);
+
+
+        if (copied) {
+            canvas_native_webgl2_draw_buffers(
+                    buf.data(), buf.size(),
+                    ptr->GetState());
+        }
+
+    }
+
+    static void DrawElementsInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastDrawElementsInstanced(v8::Local<v8::Object> receiver_obj, uint32_t mode, int32_t count,
+                              uint32_t type, int32_t offset, int32_t instanceCount) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_draw_elements_instanced(
+                mode,
+                count,
+                type,
+                static_cast<ssize_t>(offset),
+                instanceCount,
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+
+    static void DrawRangeElements(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastDrawRangeElements(v8::Local<v8::Object> receiver_obj, uint32_t mode, uint32_t start,
+                          uint32_t end, int32_t count, uint32_t type, int32_t offset) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_draw_range_elements(
+                mode,
+                start,
+                end,
+                count,
+                type,
+                static_cast<ssize_t>(offset),
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+
+    static void EndQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FenceSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferTextureLayer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockName(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniforms(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFragDataLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetIndexedParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetInternalformatParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSamplerParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSyncParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetTransformFeedbackVarying(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformBlockIndex(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformIndices(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InvalidateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastInvalidateFramebuffer(v8::Local<v8::Object> receiver_obj, uint32_t target,
+                              v8::Local<v8::Array> attachments) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = attachments->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
 
-    WebGL2RenderingContext(rust::Box<WebGLState> state, WebGLRenderingVersion version);
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                attachments, buf.data(), len);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        if (copied) {
+            canvas_native_webgl2_invalidate_framebuffer(
+                    target, buf.data(), buf.size(),
+                    ptr->GetState());
+        }
+    }
+
+    static void InvalidateSubFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastInvalidateSubFramebuffer(v8::Local<v8::Object> receiver_obj, uint32_t target,
+                                             v8::Local<v8::Array> attachments, int32_t x, int32_t y,
+                                             int32_t width, int32_t height) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = attachments->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                attachments, buf.data(), len);
+
+        if (copied) {
+
+            canvas_native_webgl2_invalidate_sub_framebuffer(
+                    target,
+                    buf.data(), buf.size(),
+                    x,
+                    y,
+                    width,
+                    height,
+                    ptr->GetState());
+        }
+    }
+
+    static void IsQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PauseTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RenderbufferStorageMultisample(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ResumeTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastResumeTransformFeedback(v8::Local<v8::Object> receiver_obj) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_webgl2_resume_transform_feedback(
+                ptr->GetState());
+    }
+
+    static void SamplerParameterf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastSamplerParameterf(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> sampler_obj,
+                          uint32_t pname, double param) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(sampler_obj);
+        if (type == NativeType::WebGLSampler) {
+            auto sampler = WebGLSampler::GetPointer(sampler_obj);
+            if (sampler != nullptr) {
+                canvas_native_webgl2_sampler_parameterf(
+                        sampler->GetSampler(),
+                        pname,
+                        static_cast<float>(param),
+                        ptr->GetState());
+            }
+        }
+
+    }
+
+    static void SamplerParameteri(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void
+    FastSamplerParameteri(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> sampler_obj,
+                          uint32_t pname, int32_t param) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(sampler_obj);
+        if (type == NativeType::WebGLSampler) {
+            auto sampler = WebGLSampler::GetPointer(sampler_obj);
+            if (sampler != nullptr) {
+                canvas_native_webgl2_sampler_parameteri(
+                        sampler->GetSampler(),
+                        pname,
+                        param,
+                        ptr->GetState());
+            }
+        }
+
+    }
+
+    static void TexImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TransformFeedbackVaryings(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void
+    FastUniform1ui(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                   uint32_t v0) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(location_obj);
+
+        if (type == NativeType::WebGLUniformLocation) {
+
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            if (location != nullptr) {
+                canvas_native_webgl2_uniform1ui(
+                        location->GetUniformLocation(),
+                        v0,
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
+
+    static void Uniform1uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniform1uiv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                    const v8::FastApiTypedArray<uint32_t> &value) {
+        WebGLRenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+        if (location != nullptr) {
+            auto size = value.length();
+            uint32_t *data;
+            value.getStorageIfAligned(&data);
+
+            canvas_native_webgl2_uniform1uiv(
+                    location->GetUniformLocation(),
+                    data, size,
+                    ptr->GetState());
+        }
+    }
+
+    static void Uniform2ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniform2ui(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                   uint32_t v0, uint32_t v1) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(location_obj);
+
+        if (type == NativeType::WebGLUniformLocation) {
+
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            if (location != nullptr) {
+                canvas_native_webgl2_uniform2ui(
+                        location->GetUniformLocation(),
+                        v0, v1,
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
+
+    static void Uniform2uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniform2uiv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                    const v8::FastApiTypedArray<uint32_t> &value) {
+        WebGLRenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+        if (location != nullptr) {
+            auto size = value.length();
+            uint32_t *data;
+            value.getStorageIfAligned(&data);
+
+            canvas_native_webgl2_uniform2uiv(
+                    location->GetUniformLocation(),
+                    data, size,
+                    ptr->GetState());
+        }
+    }
+
+    static void Uniform3ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniform3ui(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                   uint32_t v0, uint32_t v1, uint32_t v2) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(location_obj);
+
+        if (type == NativeType::WebGLUniformLocation) {
+
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            if (location != nullptr) {
+                canvas_native_webgl2_uniform3ui(
+                        location->GetUniformLocation(),
+                        v0, v1, v2,
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
+
+    static void Uniform3uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void
+    FastUniform3uiv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                    const v8::FastApiTypedArray<uint32_t> &value) {
+        WebGLRenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-    static inline jsi::Value GetProperty(const std::string &methodName) {
-        if (methodName == "READ_BUFFER") { return {0x0C02}; }
+        auto location = WebGLUniformLocation::GetPointer(location_obj);
 
-        if (methodName == "UNPACK_ROW_LENGTH") { return {0x0CF2}; }
+        if (location != nullptr) {
+            auto size = value.length();
+            uint32_t *data;
+            value.getStorageIfAligned(&data);
 
-        if (methodName == "UNPACK_SKIP_ROWS") { return {0x0CF3}; }
+            canvas_native_webgl2_uniform3uiv(
+                    location->GetUniformLocation(),
+                    data, size,
+                    ptr->GetState());
+        }
+    }
+
+    static void Uniform4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniform4ui(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                   uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto type = GetNativeType(location_obj);
+
+        if (type == NativeType::WebGLUniformLocation) {
+
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            if (location != nullptr) {
+                canvas_native_webgl2_uniform4ui(
+                        location->GetUniformLocation(),
+                        v0, v1, v2, v3,
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
+
+    static void Uniform4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void
+    FastUniform4uiv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                    const v8::FastApiTypedArray<uint32_t> &value) {
+        WebGLRenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+        if (location != nullptr) {
+            auto size = value.length();
+            uint32_t *data;
+            value.getStorageIfAligned(&data);
+
+            canvas_native_webgl2_uniform4uiv(
+                    location->GetUniformLocation(),
+                    data, size,
+                    ptr->GetState());
+        }
+    }
 
-        if (methodName == "UNPACK_SKIP_PIXELS") { return {0x0CF4}; }
+    static void UniformBlockBinding(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "PACK_ROW_LENGTH") { return {0x0D02}; }
+    static void
+    FastUniformBlockBinding(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> program_obj,
+                            uint32_t uniformBlockIndex, uint32_t uniformBlockBinding) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "PACK_SKIP_ROWS") { return {0x0D03}; }
 
-        if (methodName == "PACK_SKIP_PIXELS") { return {0x0D04}; }
+        auto type = GetNativeType(program_obj);
+        if (type == NativeType::WebGLProgram) {
 
-        if (methodName == "TEXTURE_BINDING_3D") { return {0x806A}; }
+            auto program = WebGLProgram::GetPointer(program_obj);
 
-        if (methodName == "UNPACK_SKIP_IMAGES") { return {0x806D}; }
+            if (program != nullptr) {
+                canvas_native_webgl2_uniform_block_binding(
+                        program->GetProgram(),
+                        uniformBlockIndex,
+                        uniformBlockBinding,
+                        ptr->GetState()
+                );
+            }
 
-        if (methodName == "UNPACK_IMAGE_HEIGHT") { return {0x806E}; }
+        }
 
-        if (methodName == "MAX_3D_TEXTURE_SIZE") { return {0x8073}; }
+    }
 
-        if (methodName == "MAX_ELEMENTS_VERTICES") { return {0x80E8}; }
+    static void UniformMatrix2x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastUniformMatrix2x3fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
+
+            canvas_native_webgl2_uniform_matrix2x3fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        if (methodName == "MAX_ELEMENTS_INDICES") { return {0x80E9}; }
+    }
 
-        if (methodName == "MAX_TEXTURE_LOD_BIAS") { return {0x84FD}; }
+    static void
+    FastUniformMatrix2x3fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix2x3fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
 
-        if (methodName == "MAX_FRAGMENT_UNIFORM_COMPONENTS") { return {0x8B49}; }
+    }
 
-        if (methodName == "MAX_VERTEX_UNIFORM_COMPONENTS") { return {0x8B4A}; }
+    static void UniformMatrix2x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "MAX_ARRAY_TEXTURE_LAYERS") { return {0x88FF}; }
 
-        if (methodName == "MIN_PROGRAM_TEXEL_OFFSET") { return {0x8904}; }
+    static void
+    FastUniformMatrix2x4fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "MAX_PROGRAM_TEXEL_OFFSET") { return {0x8905}; }
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
 
-        if (methodName == "MAX_VARYING_COMPONENTS") { return {0x8B4B}; }
+            canvas_native_webgl2_uniform_matrix2x4fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        if (methodName == "FRAGMENT_SHADER_DERIVATIVE_HINT") { return {0x8B8B}; }
+    }
 
-        if (methodName == "RASTERIZER_DISCARD") { return {0x8C89}; }
+    static void
+    FastUniformMatrix2x4fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix2x4fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
 
-        if (methodName == "VERTEX_ARRAY_BINDING") { return {0x85B5}; }
-        if (methodName == "MAX_VERTEX_OUTPUT_COMPONENTS") { return {0x9122}; }
-        if (methodName == "MAX_FRAGMENT_INPUT_COMPONENTS") { return {0x9125}; }
-        if (methodName == "MAX_SERVER_WAIT_TIMEOUT") { return {0x9111}; }
-        if (methodName == "MAX_ELEMENT_INDEX") { return {0x8D6B}; }
+    }
 
-        if (methodName == "RED") { return {0x1903}; }
-        if (methodName == "RGB8") { return {0x8051}; }
-        if (methodName == "RGBA8") { return {0x8058}; }
-        if (methodName == "RGB10_A2") { return {0x8059}; }
-        if (methodName == "TEXTURE_3D") { return {0x806F}; }
+    static void UniformMatrix3x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "TEXTURE_WRAP_R") { return {0x8072}; }
-        if (methodName == "TEXTURE_MIN_LOD") { return {0x813A}; }
-        if (methodName == "TEXTURE_MAX_LOD") { return {0x813B}; }
-        if (methodName == "TEXTURE_BASE_LEVEL") { return {0x813C}; }
-        if (methodName == "TEXTURE_MAX_LEVEL") { return {0x813D}; }
 
+    static void
+    FastUniformMatrix3x2fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "TEXTURE_COMPARE_MODE") { return {0x884C}; }
-        if (methodName == "TEXTURE_COMPARE_FUNC") { return {0x884D}; }
-        if (methodName == "SRGB") { return {0x8C40}; }
-        if (methodName == "SRGB8") { return {0x8C41}; }
-        if (methodName == "SRGB8_ALPHA8") { return {0x8C43}; }
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
 
-        if (methodName == "COMPARE_REF_TO_TEXTURE") { return {0x884E}; }
-        if (methodName == "RGBA32F") { return {0x8814}; }
-        if (methodName == "RGB32F") { return {0x8815}; }
-        if (methodName == "RGBA16F") { return {0x881A}; }
-        if (methodName == "RGB16F") { return {0x881B}; }
+            canvas_native_webgl2_uniform_matrix3x2fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        if (methodName == "TEXTURE_2D_ARRAY") { return {0x8C1A}; }
-        if (methodName == "TEXTURE_BINDING_2D_ARRAY") { return {0x8C1D}; }
-        if (methodName == "R11F_G11F_B10F") { return {0x8C3A}; }
-        if (methodName == "RGB9_E5") { return {0x8C3D}; }
-        if (methodName == "RGBA32UI") { return {0x8D70}; }
+    }
 
+    static void
+    FastUniformMatrix3x2fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix3x2fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
 
-        if (methodName == "RGB32UI") { return {0x8D71}; }
-        if (methodName == "RGBA16UI") { return {0x8D76}; }
-        if (methodName == "RGB16UI") { return {0x8D77}; }
-        if (methodName == "RGBA8UI") { return {0x8D7C}; }
-        if (methodName == "RGB8UI") { return {0x8D7D}; }
+    }
 
+    static void UniformMatrix3x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "RGBA32I") { return {0x8D82}; }
-        if (methodName == "RGB32I") { return {0x8D83}; }
-        if (methodName == "RGBA16I") { return {0x8D88}; }
-        if (methodName == "RGB16I") { return {0x8D89}; }
-        if (methodName == "RGBA8I") { return {0x8D8E}; }
 
+    static void
+    FastUniformMatrix3x4fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "RGB8I") { return {0x8D8F}; }
-        if (methodName == "RED_INTEGER") { return {0x8D94}; }
-        if (methodName == "RGB_INTEGER") { return {0x8D98}; }
-        if (methodName == "RGBA_INTEGER") { return {0x8D99}; }
-        if (methodName == "R8") { return {0x8229}; }
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
 
+            canvas_native_webgl2_uniform_matrix3x4fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        if (methodName == "RG8") { return {0x822B}; }
-        if (methodName == "R16F") { return {0x822D}; }
-        if (methodName == "R32F") { return {0x822E}; }
-        if (methodName == "RG16F") { return {0x822F}; }
-        if (methodName == "RG32F") { return {0x8230}; }
+    }
 
+    static void
+    FastUniformMatrix3x4fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix3x4fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
 
-        if (methodName == "R8I") { return {0x8231}; }
-        if (methodName == "R8UI") { return {0x8232}; }
-        if (methodName == "R16I") { return {0x8233}; }
-        if (methodName == "R16UI") { return {0x8234}; }
-        if (methodName == "R32I") { return {0x8235}; }
+    }
 
 
-        if (methodName == "R32UI") { return {0x8236}; }
-        if (methodName == "RG8I") { return {0x8237}; }
-        if (methodName == "RG8UI") { return {0x8238}; }
-        if (methodName == "RG16I") { return {0x8239}; }
-        if (methodName == "RG16UI") { return {0x823A}; }
-
-        if (methodName == "RG32I") { return {0x823B}; }
-        if (methodName == "RG32UI") { return {0x823C}; }
-        if (methodName == "R8_SNORM") { return {0x8F94}; }
-        if (methodName == "RG8_SNORM") { return {0x8F95}; }
-        if (methodName == "RGB8_SNORM") { return {0x8F96}; }
-
-
-        if (methodName == "RGBA8_SNORM") { return {0x8F97}; }
-        if (methodName == "RGB10_A2UI") { return {0x906F}; }
-        if (methodName == "TEXTURE_IMMUTABLE_FORMAT") { return {0x912F}; }
-        if (methodName == "TEXTURE_IMMUTABLE_LEVELS") { return {0x82DF}; }
-        if (methodName == "UNSIGNED_INT_2_10_10_10_REV") { return {0x8368}; }
-
-
-        if (methodName == "UNSIGNED_INT_10F_11F_11F_REV") { return {0x8C3B}; }
-        if (methodName == "UNSIGNED_INT_5_9_9_9_REV") { return {0x8C3E}; }
-        if (methodName == "FLOAT_32_UNSIGNED_INT_24_8_REV") { return {0x8DAD}; }
-        if (methodName == "UNSIGNED_INT_24_8") { return {0x84FA}; }
-        if (methodName == "HALF_FLOAT") { return {0x140B}; }
-
-
-        if (methodName == "RG") { return {0x8227}; }
-        if (methodName == "RG_INTEGER") { return {0x8228}; }
-        if (methodName == "INT_2_10_10_10_REV") { return {0x8D9F}; }
-        if (methodName == "QUERY_RESULT_AVAILABLE") { return {0x8865}; }
-        if (methodName == "QUERY_RESULT") { return {0x8866}; }
-
-
-        if (methodName == "CURRENT_QUERY") { return {0x8867}; }
-        if (methodName == "ANY_SAMPLES_PASSED") { return {0x8C2F}; }
-        if (methodName == "ANY_SAMPLES_PASSED_CONSERVATIVE") { return {0x8D6A}; }
-        if (methodName == "MAX_DRAW_BUFFERS") { return {0x8824}; }
-
-        if (methodName == "DRAW_BUFFER0") { return {0x8825}; }
-        if (methodName == "DRAW_BUFFER1") { return {0x8826}; }
-        if (methodName == "DRAW_BUFFER2") { return {0x8827}; }
-        if (methodName == "DRAW_BUFFER3") { return {0x8828}; }
-        if (methodName == "DRAW_BUFFER4") { return {0x8829}; }
-        if (methodName == "DRAW_BUFFER5") { return {0x882A}; }
-        if (methodName == "DRAW_BUFFER6") { return {0x882B}; }
-        if (methodName == "DRAW_BUFFER7") { return {0x882C}; }
-        if (methodName == "DRAW_BUFFER8") { return {0x882D}; }
-        if (methodName == "DRAW_BUFFER9") { return {0x882E}; }
-        if (methodName == "DRAW_BUFFER10") { return {0x882F}; }
-
-        /* Getting GL parameter information */
-
-        /* Textures */
-
-        if (methodName == "DRAW_BUFFER11") { return {0x8830}; }
-        if (methodName == "DRAW_BUFFER12") { return {0x8831}; }
-        if (methodName == "DRAW_BUFFER13") { return {0x8832}; }
-        if (methodName == "DRAW_BUFFER14") { return {0x8833}; }
-        if (methodName == "DRAW_BUFFER15") { return {0x8834}; }
-
-        if (methodName == "MAX_COLOR_ATTACHMENTS") { return {0x8CDF}; }
-        if (methodName == "COLOR_ATTACHMENT1") { return {0x8CE1}; }
-        if (methodName == "COLOR_ATTACHMENT2") { return {0x8CE2}; }
-        if (methodName == "COLOR_ATTACHMENT3") { return {0x8CE3}; }
-        if (methodName == "COLOR_ATTACHMENT4") { return {0x8CE4}; }
-        if (methodName == "COLOR_ATTACHMENT5") { return {0x8CE5}; }
-        if (methodName == "COLOR_ATTACHMENT6") { return {0x8CE6}; }
-        if (methodName == "COLOR_ATTACHMENT7") { return {0x8CE7}; }
-        if (methodName == "COLOR_ATTACHMENT8") { return {0x8CE8}; }
-        if (methodName == "COLOR_ATTACHMENT9") { return {0x8CE9}; }
-        if (methodName == "COLOR_ATTACHMENT10") { return {0x8CEA}; }
-        if (methodName == "COLOR_ATTACHMENT11") { return {0x8CEB}; }
-        if (methodName == "COLOR_ATTACHMENT12") { return {0x8CEC}; }
-        if (methodName == "COLOR_ATTACHMENT13") { return {0x8CED}; }
-        if (methodName == "COLOR_ATTACHMENT14") { return {0x8CEE}; }
-        if (methodName == "COLOR_ATTACHMENT15") { return {0x8CEF}; }
-
-        if (methodName == "SAMPLER_3D") { return {0x8B5F}; }
-        if (methodName == "SAMPLER_2D_SHADOW") { return {0x8B62}; }
-        if (methodName == "SAMPLER_2D_ARRAY") { return {0x8DC1}; }
-        if (methodName == "SAMPLER_2D_ARRAY_SHADOW") { return {0x8DC4}; }
-        if (methodName == "SAMPLER_CUBE_SHADOW") { return {0x8DC5}; }
-
-        if (methodName == "INT_SAMPLER_2D") { return {0x8DCA}; }
-        if (methodName == "INT_SAMPLER_3D") { return {0x8DCB}; }
-        if (methodName == "INT_SAMPLER_CUBE") { return {0x8DCC}; }
-        if (methodName == "INT_SAMPLER_2D_ARRAY") { return {0x8DCF}; }
-        if (methodName == "UNSIGNED_INT_SAMPLER_2D") { return {0x8DD2}; }
-
-        if (methodName == "UNSIGNED_INT_SAMPLER_3D") { return {0x8DD3}; }
-        if (methodName == "UNSIGNED_INT_SAMPLER_CUBE") { return {0x8DD4}; }
-        if (methodName == "UNSIGNED_INT_SAMPLER_2D_ARRAY") { return {0x8DD7}; }
-        if (methodName == "MAX_SAMPLES") { return {0x8D57}; }
-        if (methodName == "SAMPLER_BINDING") { return {0x8919}; }
-
-        if (methodName == "PIXEL_PACK_BUFFER") { return {0x88EB}; }
-        if (methodName == "PIXEL_UNPACK_BUFFER") { return {0x88EC}; }
-        if (methodName == "PIXEL_PACK_BUFFER_BINDING") { return {0x88ED}; }
-        if (methodName == "PIXEL_UNPACK_BUFFER_BINDING") { return {0x88EF}; }
-        if (methodName == "COPY_READ_BUFFER") { return {0x8F36}; }
-
-        if (methodName == "COPY_WRITE_BUFFER") { return {0x8F37}; }
-        if (methodName == "COPY_READ_BUFFER_BINDING") { return {0x8F36}; }
-        if (methodName == "COPY_WRITE_BUFFER_BINDING") { return {0x8F37}; }
-        if (methodName == "FLOAT_MAT2x3") { return {0x8B65}; }
-        if (methodName == "FLOAT_MAT2x4") { return {0x8B66}; }
-
-        if (methodName == "FLOAT_MAT3x2") { return {0x8B67}; }
-        if (methodName == "FLOAT_MAT3x4") { return {0x8B68}; }
-        if (methodName == "FLOAT_MAT4x2") { return {0x8B69}; }
-        if (methodName == "FLOAT_MAT4x3") { return {0x8B6A}; }
-        if (methodName == "UNSIGNED_INT_VEC2") { return {0x8DC6}; }
-
-        if (methodName == "UNSIGNED_INT_VEC3") { return {0x8DC7}; }
-        if (methodName == "UNSIGNED_INT_VEC4") { return {0x8DC8}; }
-        if (methodName == "UNSIGNED_NORMALIZED") { return {0x8C17}; }
-        if (methodName == "SIGNED_NORMALIZED") { return {0x8F9C}; }
-
-        /* Vertex attributes */
-
-        if (methodName == "VERTEX_ATTRIB_ARRAY_INTEGER") { return {0x88FD}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_DIVISOR") { return {0x88FE}; }
-        if (methodName == "TRANSFORM_FEEDBACK_BUFFER_MODE") { return {0x8C7F}; }
-        if (methodName == "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS") { return {0x8C80}; }
-        if (methodName == "TRANSFORM_FEEDBACK_VARYINGS") { return {0x8C83}; }
-
-        if (methodName == "TRANSFORM_FEEDBACK_BUFFER_START") { return {0x8C84}; }
-        if (methodName == "TRANSFORM_FEEDBACK_BUFFER_SIZE") { return {0x8C85}; }
-        if (methodName == "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN") { return {0x8C88}; }
-        if (methodName == "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS") { return {0x8C8A}; }
-
-        /* Textures */
-
-        /* Pixel types */
-
-        if (methodName == "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS") { return {0x8C8B}; }
-        if (methodName == "INTERLEAVED_ATTRIBS") { return {0x8C8C}; }
-        if (methodName == "SEPARATE_ATTRIBS") { return {0x8C8D}; }
-        if (methodName == "TRANSFORM_FEEDBACK_BUFFER") { return {0x8C8E}; }
-        if (methodName == "TRANSFORM_FEEDBACK_BUFFER_BINDING") { return {0x8C8F}; }
-
-        if (methodName == "TRANSFORM_FEEDBACK") { return {0x8E22}; }
-        if (methodName == "TRANSFORM_FEEDBACK_PAUSED") { return {0x8E23}; }
-        if (methodName == "TRANSFORM_FEEDBACK_ACTIVE") { return {0x8E24}; }
-        if (methodName == "TRANSFORM_FEEDBACK_BINDING") { return {0x8E25}; }
-
-        /* Pixel types */
-
-        /* Queries */
-
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING") { return {0x8210}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE") { return {0x8211}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_RED_SIZE") { return {0x8212}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE") { return {0x8213}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE") { return {0x8214}; }
-
-        /* Queries */
-
-        /* Draw buffers */
-
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE") { return {0x8215}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE") { return {0x8216}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE") { return {0x8217}; }
-        if (methodName == "FRAMEBUFFER_DEFAULT") { return {0x8218}; }
-        if (methodName == "DEPTH_STENCIL_ATTACHMENT") { return {0x821A}; }
-
-        if (methodName == "DEPTH_STENCIL") { return {0x84F9}; }
-        if (methodName == "DEPTH24_STENCIL8") { return {0x88F0}; }
-        if (methodName == "DRAW_FRAMEBUFFER_BINDING") { return {0x8CA6}; }
-        if (methodName == "READ_FRAMEBUFFER") { return {0x8CA8}; }
-        if (methodName == "DRAW_FRAMEBUFFER") { return {0x8CA9}; }
-
-        if (methodName == "READ_FRAMEBUFFER_BINDING") { return {0x8CAA}; }
-        if (methodName == "RENDERBUFFER_SAMPLES") { return {0x8CAB}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER") { return {0x8CD4}; }
-        if (methodName == "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE") { return {0x8D56}; }
-        if (methodName == "UNIFORM_BUFFER") { return {0x8A11}; }
-
-        if (methodName == "UNIFORM_BUFFER_BINDING") { return {0x8A28}; }
-        if (methodName == "UNIFORM_BUFFER_START") { return {0x8A29}; }
-        if (methodName == "UNIFORM_BUFFER_SIZE") { return {0x8A2A}; }
-        if (methodName == "MAX_VERTEX_UNIFORM_BLOCKS") { return {0x8A2B}; }
-        if (methodName == "MAX_FRAGMENT_UNIFORM_BLOCKS") { return {0x8A2D}; }
-
-        if (methodName == "MAX_COMBINED_UNIFORM_BLOCKS") { return {0x8A2E}; }
-        if (methodName == "MAX_UNIFORM_BUFFER_BINDINGS") { return {0x8A2F}; }
-        if (methodName == "MAX_UNIFORM_BLOCK_SIZE") { return {0x8A30}; }
-        if (methodName == "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS") { return {0x8A31}; }
-        if (methodName == "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS") { return {0x8A33}; }
-
-        if (methodName == "UNIFORM_BUFFER_OFFSET_ALIGNMENT") { return {0x8A34}; }
-        if (methodName == "ACTIVE_UNIFORM_BLOCKS") { return {0x8A36}; }
-        if (methodName == "UNIFORM_TYPE") { return {0x8A37}; }
-        if (methodName == "UNIFORM_SIZE") { return {0x8A38}; }
-        if (methodName == "UNIFORM_BLOCK_INDEX") { return {0x8A3A}; }
-
-        if (methodName == "UNIFORM_OFFSET") { return {0x8A3B}; }
-        if (methodName == "UNIFORM_ARRAY_STRIDE") { return {0x8A3C}; }
-        if (methodName == "UNIFORM_MATRIX_STRIDE") { return {0x8A3D}; }
+    static void UniformMatrix4x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Draw buffers */
+    static void
+    FastUniformMatrix4x2fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        /* Samplers */
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
 
-        if (methodName == "UNIFORM_IS_ROW_MAJOR") { return {0x8A3E}; }
-        if (methodName == "UNIFORM_BLOCK_BINDING") { return {0x8A3F}; }
-        if (methodName == "UNIFORM_BLOCK_DATA_SIZE") { return {0x8A40}; }
-        if (methodName == "UNIFORM_BLOCK_ACTIVE_UNIFORMS") { return {0x8A42}; }
-        if (methodName == "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES") { return {0x8A43}; }
+            canvas_native_webgl2_uniform_matrix4x2fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        if (methodName == "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER") { return {0x8A44}; }
-        if (methodName == "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER") { return {0x8A46}; }
-        if (methodName == "OBJECT_TYPE") { return {0x9112}; }
-        if (methodName == "SYNC_CONDITION") { return {0x9113}; }
-        if (methodName == "SYNC_STATUS") { return {0x9114}; }
+    }
+
+    static void
+    FastUniformMatrix4x2fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix4x2fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
 
-        if (methodName == "SYNC_FLAGS") { return {0x9115}; }
-        if (methodName == "SYNC_FENCE") { return {0x9116}; }
-        if (methodName == "SYNC_GPU_COMMANDS_COMPLETE") { return {0x9117}; }
-        if (methodName == "UNSIGNALED") { return {0x9118}; }
-        if (methodName == "SIGNALED") { return {0x9119}; }
+    static void UniformMatrix4x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Samplers */
 
-        /* Buffers */
+    static void
+    FastUniformMatrix4x3fv(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> location_obj,
+                           bool transpose, const v8::FastApiTypedArray<float> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "ALREADY_SIGNALED") { return {0x911A}; }
-        if (methodName == "TIMEOUT_EXPIRED") { return {0x911B}; }
-        if (methodName == "CONDITION_SATISFIED") { return {0x911C}; }
-        if (methodName == "WAIT_FAILED") { return {0x911D}; }
-        if (methodName == "SYNC_FLUSH_COMMANDS_BIT") { return {0x00000001}; }
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+            auto size = data_value.length();
+            float *data;
+            data_value.getStorageIfAligned(&data);
 
-        if (methodName == "COLOR") { return {0x1800}; }
-        if (methodName == "DEPTH") { return {0x1801}; }
-        if (methodName == "STENCIL") { return {0x1802}; }
+            canvas_native_webgl2_uniform_matrix4x3fv(
+                    location->GetUniformLocation(),
+                    transpose,
+                    data, size,
+                    ptr->GetState()
+            );
+        }
 
-        /* Buffers */
+    }
+
+    static void
+    FastUniformMatrix4x3fvArray(v8::Local<v8::Object> receiver_obj,
+                                v8::Local<v8::Object> location_obj,
+                                bool transpose, v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto type = GetNativeType(location_obj);
+        if (type == NativeType::WebGLUniformLocation) {
+            auto location = WebGLUniformLocation::GetPointer(location_obj);
+
+            auto len = data_value->Length();
+            std::vector<float> buf;
+            buf.reserve(len);
+
+            auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                    data_value, buf.data(), len);
+
+            if (copied) {
+                canvas_native_webgl2_uniform_matrix4x3fv(
+                        location->GetUniformLocation(),
+                        transpose,
+                        buf.data(), buf.size(),
+                        ptr->GetState()
+                );
+            }
+        }
+
+    }
 
-        /* Data types */
+    static void VertexAttribDivisor(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "MIN") { return {0x8007}; }
-        if (methodName == "MAX") { return {0x8008}; }
-        if (methodName == "DEPTH_COMPONENT24") { return {0x81A6}; }
-        if (methodName == "STREAM_READ") { return {0x88E1}; }
-        if (methodName == "STREAM_COPY") { return {0x88E2}; }
+    static void
+    FastVertexAttribDivisor(v8::Local<v8::Object> receiver_obj, uint32_t index, uint32_t divisor) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        if (methodName == "STATIC_READ") { return {0x88E5}; }
-        if (methodName == "STATIC_COPY") { return {0x88E6}; }
-        if (methodName == "DYNAMIC_READ") { return {0x88E9}; }
-        if (methodName == "DYNAMIC_COPY") { return {0x88EA}; }
-        if (methodName == "DEPTH_COMPONENT32F") { return {0x8CAC}; }
-        if (methodName == "DEPTH32F_STENCIL8") { return {0x8CAD}; }
+        canvas_native_webgl2_vertex_attrib_divisor(
+                index,
+                divisor,
+                ptr->GetState()
+        );
 
-        /* Data types */
+    }
+
+    static void VertexAttribI4i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastVertexAttribI4i(v8::Local<v8::Object> receiver_obj, int32_t index, int32_t v0, int32_t v1,
+                        int32_t v2, int32_t v3) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_vertex_attrib_i4i(
+                index,
+                v0,
+                v1,
+                v2,
+                v3,
+                ptr->GetState()
+        );
+
+    }
+
+    static void VertexAttribI4iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FastVertexAttribI4iv(v8::Local<v8::Object> receiver_obj, uint32_t index,
+                                     const v8::FastApiTypedArray<int32_t> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto size = data_value.length();
+        int32_t *data;
+        data_value.getStorageIfAligned(&data);
+
+        canvas_native_webgl2_vertex_attrib_i4iv(
+                index,
+                data, size,
+                ptr->GetState()
+        );
+
+    }
+
+    static void FastVertexAttribI4ivArray(v8::Local<v8::Object> receiver_obj, uint32_t index,
+                                          v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto len = data_value->Length();
+        std::vector<int32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<int32_t>::Build().GetId(), int32_t>(
+                data_value, buf.data(), len);
+
+
+        if (copied) {
+            canvas_native_webgl2_vertex_attrib_i4iv(
+                    index,
+                    buf.data(), buf.size(),
+                    ptr->GetState()
+            );
+        }
+
+    }
+
+    static void VertexAttribI4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastVertexAttribI4ui(v8::Local<v8::Object> receiver_obj, uint32_t index, uint32_t v0,
+                         uint32_t v1,
+                         uint32_t v2, uint32_t v3) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        canvas_native_webgl2_vertex_attrib_i4ui(
+                index,
+                v0,
+                v1,
+                v2,
+                v3,
+                ptr->GetState()
+        );
+
+    }
+
+    static void VertexAttribI4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void FastVertexAttribI4uiv(v8::Local<v8::Object> receiver_obj, uint32_t index,
+                                      const v8::FastApiTypedArray<uint32_t> &data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        auto size = data_value.length();
+        uint32_t *data;
+        data_value.getStorageIfAligned(&data);
+
+        canvas_native_webgl2_vertex_attrib_i4uiv(
+                index,
+                data, size,
+                ptr->GetState()
+        );
+
+    }
 
-        if (methodName == "INVALID_INDEX") { return {(double) 0xFFFFFFFF}; }
-        if (methodName == "TIMEOUT_IGNORED") { return {-1}; }
+    static void FastVertexAttribI4uivArray(v8::Local<v8::Object> receiver_obj, uint32_t index,
+                                           v8::Local<v8::Array> data_value) {
+        WebGL2RenderingContext *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
 
-        /* Vertex attributes */
+        auto len = data_value->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
 
-        /* Transform feedback */
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                data_value, buf.data(), len);
 
-        if (methodName == "MAX_CLIENT_WAIT_TIMEOUT_WEBGL") { return {0x9247}; }
 
-        /* Transform feedback */
+        if (copied) {
+            canvas_native_webgl2_vertex_attrib_i4uiv(
+                    index,
+                    buf.data(), buf.size(),
+                    ptr->GetState()
+            );
+        }
 
-        return jsi::Value::undefined();
     }
 
 };