@nativescript/canvas 2.0.0-beta.2 → 2.0.0-beta.21

package/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp

@@ -754,7 +754,7 @@ v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *is
             auto array = v8::Array::New(isolate, (int) len);
 
             for (int j = 0; j < len; ++j) {
-                array->Set(context, j, v8::Boolean::New(isolate, buf[j] == 1));
+                array->Set(context, j, v8::Boolean::New(isolate, buf[j] == 1)).FromJust();
             }
             return scope.Escape(array);
         }
@@ -894,8 +894,6 @@ void WebGLRenderingContext::AttachShader(const v8::FunctionCallbackInfo<v8::Valu
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto programValue = args[0];
     auto shaderValue = args[1];
 
@@ -1200,59 +1198,24 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
         auto usage = args[2]->Uint32Value(context).ToChecked();
 
         if (args[1]->IsObject()) {
-
             auto sizeOrBuf = args[1];
             if (sizeOrBuf->IsArrayBufferView()) {
-                if (sizeOrBuf->IsUint16Array()) {
-                    auto buf = sizeOrBuf.As<v8::Uint16Array>();
-
-                    auto array = buf->Buffer();
-                    auto offset = buf->ByteOffset();
-                    auto size = buf->Length();
-                    auto data_ptr =
-                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-                    auto data = static_cast<uint16_t *>((void *) data_ptr);
-
-                    canvas_native_webgl_buffer_data_u16(
-                            target,
-                            data, size,
-                            usage,
-                            ptr->GetState()
-                    );
-                } else if (sizeOrBuf->IsFloat32Array()) {
-                    auto buf = sizeOrBuf.As<v8::Float32Array>();
-
-                    auto array = buf->Buffer();
-                    auto offset = buf->ByteOffset();
-                    auto size = buf->Length();
-                    auto data_ptr =
-                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-                    auto data = static_cast<float *>((void *) data_ptr);
-
-                    canvas_native_webgl_buffer_data_f32(
-                            target,
-                            data, size,
-                            usage,
-                            ptr->GetState()
-                    );
-                } else {
-                    auto buf = sizeOrBuf.As<v8::ArrayBufferView>();
+                auto buf = sizeOrBuf.As<v8::ArrayBufferView>();
 
-                    auto array = buf->Buffer();
-                    auto offset = buf->ByteOffset();
-                    auto size = buf->ByteLength();
-                    auto data_ptr =
-                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-                    auto data = static_cast<uint8_t *>((void *) data_ptr);
+                auto array = buf->Buffer();
+                auto offset = buf->ByteOffset();
+                auto size = buf->ByteLength();
+                auto data_ptr =
+                        static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+                auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
-                    canvas_native_webgl_buffer_data(
-                            target,
-                            data, size,
-                            usage,
-                            ptr->GetState()
-                    );
-                }
+                canvas_native_webgl_buffer_data(
+                        target,
+                        data, size,
+                        usage,
+                        ptr->GetState()
+                );
             } else if (sizeOrBuf->IsArrayBuffer()) {
                 auto array = sizeOrBuf.As<v8::ArrayBuffer>();
 
@@ -1524,8 +1487,7 @@ void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->ByteLength();
-                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-                auto data = static_cast<uint8_t *>((void *) data_ptr);
+                auto data = static_cast<const uint8_t *>(array->GetBackingStore()->Data()) + offset;
 
 
                 canvas_native_webgl_compressed_tex_image2d(
@@ -1583,8 +1545,7 @@ WebGLRenderingContext::CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8
         auto array = buf->Buffer();
         auto offset = buf->ByteOffset();
         auto size = array->ByteLength();
-        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-        auto data = static_cast<uint8_t *>((void *) data_ptr);
+        auto data = static_cast<const uint8_t *>(array->GetBackingStore()->Data()) + offset;
 
         canvas_native_webgl_compressed_tex_sub_image2d(
                 target,
@@ -1854,9 +1815,6 @@ void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo<v8::Valu
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLBuffer) {
@@ -1877,8 +1835,6 @@ void WebGLRenderingContext::DeleteFramebuffer(const v8::FunctionCallbackInfo<v8:
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLFramebuffer) {
@@ -1899,8 +1855,6 @@ void WebGLRenderingContext::DeleteProgram(const v8::FunctionCallbackInfo<v8::Val
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
 
@@ -1923,8 +1877,6 @@ void WebGLRenderingContext::DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
 
     auto value = args[0];
     auto type = GetNativeType(value);
@@ -1948,8 +1900,6 @@ void WebGLRenderingContext::DeleteShader(const v8::FunctionCallbackInfo<v8::Valu
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
 
     auto value = args[0];
     auto type = GetNativeType(value);
@@ -1971,8 +1921,6 @@ void WebGLRenderingContext::DeleteTexture(const v8::FunctionCallbackInfo<v8::Val
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
 
     auto value = args[0];
     auto type = GetNativeType(value);
@@ -2049,8 +1997,6 @@ void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Valu
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
 
     auto programValue = args[0];
     auto shaderValue = args[1];
@@ -2398,7 +2344,7 @@ void WebGLRenderingContext::GetAttachedShaders(const v8::FunctionCallbackInfo<v8
             for (int i = 0; i < len; ++i) {
                 auto shader = WebGLShader::NewInstance(isolate, new WebGLShader(
                         buf[i]));
-                array->Set(context, i, shader);
+                array->Set(context, i, shader).FromJust();
             }
             args.GetReturnValue().Set(array);
 
@@ -2484,63 +2430,81 @@ void WebGLRenderingContext::GetContextAttributes(const v8::FunctionCallbackInfo<
             attr);
 
 
-    ret->Set(context, ConvertToV8String(isolate, "alpha"), v8::Boolean::New(isolate, alpha));
+    ret->Set(context, ConvertToV8String(isolate, "alpha"),
+             v8::Boolean::New(isolate, alpha)).FromJust();
 
     auto antialias = canvas_native_webgl_context_attribute_get_get_antialias(
             attr);
 
     ret->Set(context, ConvertToV8String(isolate, "antialias"),
-             v8::Boolean::New(isolate, antialias));
+             v8::Boolean::New(isolate, antialias)).FromJust();
 
     auto depth = canvas_native_webgl_context_attribute_get_get_depth(
             attr);
 
-    ret->Set(context, ConvertToV8String(isolate, "depth"), v8::Boolean::New(isolate, depth));
+    ret->Set(context, ConvertToV8String(isolate, "depth"),
+             v8::Boolean::New(isolate, depth)).FromJust();
 
     auto fail_if_major_performance_caveat = canvas_native_webgl_context_attribute_get_get_fail_if_major_performance_caveat(
             attr);
 
     ret->Set(context,
              ConvertToV8String(isolate, "failIfMajorPerformanceCaveat"),
-             v8::Boolean::New(isolate, fail_if_major_performance_caveat));
+             v8::Boolean::New(isolate, fail_if_major_performance_caveat)).FromJust();
 
     auto power_preference = canvas_native_webgl_context_attribute_get_get_power_preference(
             attr);
 
+    std::string powerp;
+    switch (power_preference) {
+        case 0:
+            powerp = std::string("default");
+            break;
+        case 1:
+            powerp = std::string("high-performance");
+            break;
+        case 2:
+            powerp = std::string("low-power");
+            break;
+        default:
+            break;
+    }
+
     ret->Set(context, ConvertToV8String(isolate, "powerPreference"),
-             ConvertToV8OneByteString(isolate, (char *) power_preference));
+             ConvertToV8String(isolate, powerp.c_str())).FromJust();
+
 
     auto premultiplied_alpha = canvas_native_webgl_context_attribute_get_get_premultiplied_alpha(
             attr);
 
     ret->Set(context,
              ConvertToV8String(isolate, "premultipliedAlpha"),
-             v8::Boolean::New(isolate, premultiplied_alpha));
+             v8::Boolean::New(isolate, premultiplied_alpha)).FromJust();
 
     auto preserve_drawing_buffer = canvas_native_webgl_context_attribute_get_get_preserve_drawing_buffer(
             attr);
 
     ret->Set(context,
              ConvertToV8String(isolate, "preserveDrawingBuffer"),
-             v8::Boolean::New(isolate, preserve_drawing_buffer));
+             v8::Boolean::New(isolate, preserve_drawing_buffer)).FromJust();
 
     auto stencil = canvas_native_webgl_context_attribute_get_get_stencil(
             attr);
 
     ret->Set(context, ConvertToV8String(isolate, "stencil"),
-             v8::Boolean::New(isolate, stencil));
+             v8::Boolean::New(isolate, stencil)).FromJust();
 
     auto desynchronized = canvas_native_webgl_context_attribute_get_get_desynchronized(
             attr);
 
     ret->Set(context, ConvertToV8String(isolate, "desynchronized"),
-             v8::Boolean::New(isolate, desynchronized));
+             v8::Boolean::New(isolate, desynchronized)).FromJust();
 
     auto xr_compatible = canvas_native_webgl_context_attribute_get_get_xr_compatible(
             attr);
 
     ret->Set(context, ConvertToV8String(isolate, "xrCompatible"),
-             v8::Boolean::New(isolate, xr_compatible));
+             v8::Boolean::New(isolate, xr_compatible)).FromJust();
 
     canvas_native_context_attributes_destroy(attr);
 
@@ -2622,7 +2586,6 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
                                                                            ret));
 
             args.GetReturnValue().Set(query);
-            canvas_native_webgl_extension_destroy(ext);
             return;
         }
         case WebGLExtensionType::WebGLExtensionTypeEXT_sRGB: {
@@ -2692,7 +2655,6 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
                                                                   new OES_vertex_array_objectImpl(
                                                                           ret));
             args.GetReturnValue().Set(array);
-            canvas_native_webgl_extension_destroy(ext);
             return;
         }
         case WebGLExtensionType::WebGLExtensionTypeWEBGL_color_buffer_float: {
@@ -2701,7 +2663,7 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
             if (ptr->GetVersion() ==
                 WebGLRenderingVersion::V2) {
                 ret->Set(context, ConvertToV8String(isolate, "ext_name"),
-                         ConvertToV8String(isolate, "EXT_color_buffer_float"));
+                         ConvertToV8String(isolate, "EXT_color_buffer_float")).FromJust();
             }
             args.GetReturnValue().Set(ret);
             canvas_native_webgl_extension_destroy(ext);
@@ -2755,8 +2717,6 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
                                                            new WEBGL_lose_contextImpl(ret));
 
             args.GetReturnValue().Set(ctx);
-
-            canvas_native_webgl_extension_destroy(ext);
             return;
         }
         case WebGLExtensionType::WebGLExtensionTypeANGLE_instanced_arrays: {
@@ -2766,7 +2726,6 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
                                                                             ret));
 
             args.GetReturnValue().Set(instance);
-            canvas_native_webgl_extension_destroy(ext);
             return;
         }
         case WebGLExtensionType::WebGLExtensionTypeWEBGL_depth_texture: {
@@ -2782,8 +2741,6 @@ void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Valu
                                                                new WEBGL_draw_buffersImpl(ret));
 
             args.GetReturnValue().Set(buffers);
-
-            canvas_native_webgl_extension_destroy(ext);
             return;
 
 
@@ -2846,7 +2803,7 @@ void WebGLRenderingContext::GetFramebufferAttachmentParameter(
         object->Set(context,
                     ConvertToV8String(isolate, "isRenderbuffer"),
                     v8::Boolean::New(isolate,
-                                     true));
+                                     true)).FromJust();
         args.GetReturnValue().Set(object);
 
         canvas_native_webgl_framebuffer_attachment_parameter_destroy(ret);
@@ -2906,7 +2863,6 @@ void WebGLRenderingContext::GetProgramInfoLog(const v8::FunctionCallbackInfo<v8:
 
             if (strlen(log) == 0) {
                 args.GetReturnValue().SetEmptyString();
-                canvas_native_string_destroy((char *) log);
                 return;
             }
 
@@ -3015,7 +2971,6 @@ void WebGLRenderingContext::GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::
 
             if (strlen(log) == 0) {
                 args.GetReturnValue().SetEmptyString();
-                canvas_native_string_destroy((char *) log);
                 return;
             }
 
@@ -3131,7 +3086,6 @@ void WebGLRenderingContext::GetShaderSource(const v8::FunctionCallbackInfo<v8::V
 
             if (strlen(source) == 0) {
                 args.GetReturnValue().SetEmptyString();
-                canvas_native_string_destroy((char *) source);
                 return;
             }
 
@@ -3164,7 +3118,7 @@ WebGLRenderingContext::GetSupportedExtensions(const v8::FunctionCallbackInfo<v8:
     for (int i = 0; i < len; ++i) {
         auto item = canvas_native_string_buffer_get_value_at(exts, i);
         if (item != nullptr) {
-            array->Set(context, i, ConvertToV8OneByteString(isolate, (char *) item));
+            array->Set(context, i, ConvertToV8OneByteString(isolate, (char *) item)).FromJust();
         }
 
     }
@@ -3314,7 +3268,7 @@ WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &arg
                                 context, i,
                                 v8::Boolean::New(isolate,
                                                  item ==
-                                                 1));
+                                                 1)).FromJust();
                     }
                     args.GetReturnValue().Set(array);
                     canvas_native_webgl_WebGLResult_destroy(val);
@@ -3560,7 +3514,6 @@ WebGLRenderingContext::IsBuffer(const v8::FunctionCallbackInfo<v8::Value> &args)
         return;
     }
 
-    auto isolate = args.GetIsolate();
 
     auto value = args[0];
     auto type = GetNativeType(value);
@@ -3619,8 +3572,6 @@ WebGLRenderingContext::IsFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLFramebuffer) {
@@ -3642,12 +3593,10 @@ void
 WebGLRenderingContext::IsProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
+        args.GetReturnValue().Set(false);
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLProgram) {
@@ -3674,8 +3623,6 @@ WebGLRenderingContext::IsRenderbuffer(const v8::FunctionCallbackInfo<v8::Value>
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLRenderbuffer) {
@@ -3702,8 +3649,6 @@ WebGLRenderingContext::IsShader(const v8::FunctionCallbackInfo<v8::Value> &args)
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLShader) {
@@ -3729,8 +3674,6 @@ WebGLRenderingContext::IsTexture(const v8::FunctionCallbackInfo<v8::Value> &args
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLTexture) {
@@ -3773,7 +3716,6 @@ WebGLRenderingContext::LinkProgram(const v8::FunctionCallbackInfo<v8::Value> &ar
         return;
     }
 
-    auto isolate = args.GetIsolate();
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLProgram) {
@@ -4215,7 +4157,6 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                 if (image_asset !=
                     nullptr) {
 
-
                     canvas_native_webgl_tex_image2d_image_asset(
                             target,
                             level,
@@ -4279,6 +4220,30 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                 }
                 return;
             }
+            case NativeType::ImageData: {
+                auto image_data = ImageDataImpl::GetPointer(pixels.As<v8::Object>());
+                if (image_data != nullptr) {
+                    auto width = canvas_native_image_data_get_width(image_data->GetImageData());
+                    auto height = canvas_native_image_data_get_height(image_data->GetImageData());
+                    auto buffer = canvas_native_image_data_get_data(image_data->GetImageData());
+                    auto size = canvas_native_u8_buffer_get_length(buffer);
+                    auto data = canvas_native_u8_buffer_get_bytes(buffer);
+                    canvas_native_webgl_tex_image2d(
+                            target,
+                            level,
+                            internalformat,
+                            width,
+                            height,
+                            format,
+                            type,
+                            GL_RGBA,
+                            data,
+                            size,
+                            ptr->GetState()
+                    );
+                }
+
+            }
             default:
                 break;
         }
@@ -4348,8 +4313,7 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
             auto array = buf->Buffer();
             auto offset = buf->ByteOffset();
             auto size = array->ByteLength();
-            auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<uint8_t *>((void *) data_ptr);
+            auto data = static_cast<const uint8_t *>(array->GetBackingStore()->Data()) + offset;
 
 
             canvas_native_webgl_tex_image2d(
@@ -4538,6 +4502,30 @@ WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &
                 }
                 return;
             }
+            case NativeType::ImageData: {
+                auto image_data = ImageDataImpl::GetPointer(pixels.As<v8::Object>());
+                if (image_data != nullptr) {
+                    auto width = canvas_native_image_data_get_width(image_data->GetImageData());
+                    auto height = canvas_native_image_data_get_height(image_data->GetImageData());
+                    auto buffer = canvas_native_image_data_get_data(image_data->GetImageData());
+                    auto size = canvas_native_u8_buffer_get_length(buffer);
+                    auto data = canvas_native_u8_buffer_get_bytes(buffer);
+                    canvas_native_webgl_tex_sub_image2d(
+                            target,
+                            level,
+                            xoffset,
+                            yoffset,
+                            width,
+                            height,
+                            format,
+                            GL_RGBA,
+                            data,
+                            size,
+                            ptr->GetState()
+                    );
+                }
+
+            }
             default:
                 break;
         }
@@ -4569,8 +4557,7 @@ WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &
             auto array = buf->Buffer();
             auto offset = buf->ByteOffset();
             auto size = array->ByteLength();
-            auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<uint8_t *>((void *) data_ptr);
+            auto data = static_cast<const uint8_t *>(array->GetBackingStore()->Data()) + offset;
 
 
             canvas_native_webgl_tex_sub_image2d(
@@ -4717,7 +4704,6 @@ WebGLRenderingContext::VertexAttrib1fv(const v8::FunctionCallbackInfo<v8::Value>
     auto value = args[1];
     if (value->IsFloat32Array()) {
         auto buf = value.As<v8::Float32Array>();
-
         auto array = buf->Buffer();
         auto offset = buf->ByteOffset();
         auto size = buf->Length();
@@ -5705,10 +5691,8 @@ WebGLRenderingContext::UseProgram(const v8::FunctionCallbackInfo<v8::Value> &arg
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
-    if (value->IsNull()) {
+    if (value->IsNullOrUndefined()) {
         canvas_native_webgl_use_program(0,
                                         ptr->GetState());
 
@@ -5735,8 +5719,6 @@ WebGLRenderingContext::ValidateProgram(const v8::FunctionCallbackInfo<v8::Value>
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::WebGLProgram) {
@@ -6302,6 +6284,10 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local<v8::Obje
                   v8::Local<v8::Value>());
 
 
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
+
     // todo
     tmpl->Set(ConvertToV8String(isolate, "__toDataURL"),
               v8::FunctionTemplate::New(isolate, &__ToDataURL));

package/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp

@@ -7,8 +7,8 @@
 WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                                                      WebGLRenderingVersion version)
 : state_(state), version_(version) {
-    
-    
+
+
     auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
     auto raf_callback = new OnRafCallback(
                                           ctx_ptr,
@@ -19,13 +19,44 @@ WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                  std::make_shared<RafImpl>(
                                            raf_callback,
                                            raf_callback_ptr, raf));
-    
+
     auto _raf = this->GetRaf();
-    
+
     if (_raf != nullptr) {
         canvas_native_raf_start(_raf->GetRaf());
     }
-    
+
+}
+
+
+void WebGLRenderingContextBase::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void WebGLRenderingContextBase::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto val = value->BooleanValue(isolate);
+    if (val == ptr->continuousRender_) {
+        return;
+    }
+    if (val) {
+        ptr->StartRaf();
+    } else {
+        ptr->StopRaf();
+    }
+    ptr->continuousRender_ = val;
 }
 
 
@@ -64,8 +95,7 @@ void WebGLRenderingContextBase::Flush() {
     auto state = this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState((int) InvalidateState::InvalidateStateInvalidating);
-        canvas_native_webgl_make_current(this->GetState());
-        canvas_native_webgl_swap_buffers(this->GetState());
+        canvas_native_webgl_make_current_and_swap_buffers(this->GetState());
         this->SetInvalidateState((int) InvalidateState::InvalidateStateNone);
     }
 }

package/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.h

@@ -32,6 +32,14 @@ public:
         return static_cast<WebGLRenderingContextBase *>(ptr);
     }
 
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            v8::Local<v8::Value> value,
+                                                            const v8::PropertyCallbackInfo<void> &info);
+
     ~WebGLRenderingContextBase();
 
     void UpdateInvalidateState();
@@ -66,5 +74,7 @@ private:
     int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
 
     std::shared_ptr<RafImpl> raf_;
+
+    bool continuousRender_ = true;
 };