diff --git a/packages/canvas-babylon/package.json b/packages/canvas-babylon/package.json index 651ba9edb..f6551cb54 100644 --- a/packages/canvas-babylon/package.json +++ b/packages/canvas-babylon/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-babylon", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-chartjs/package.json b/packages/canvas-chartjs/package.json index 6f81e90e5..5669eef63 100644 --- a/packages/canvas-chartjs/package.json +++ b/packages/canvas-chartjs/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-chartjs", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "ChartJS", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-media/package.json b/packages/canvas-media/package.json index 15f92452f..30c21e98f 100644 --- a/packages/canvas-media/package.json +++ b/packages/canvas-media/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-media", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Canvas media", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-phaser-ce/package.json b/packages/canvas-phaser-ce/package.json index ff62af409..465c9d75c 100644 --- a/packages/canvas-phaser-ce/package.json +++ b/packages/canvas-phaser-ce/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-phaser-ce", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Tools for using Phaser-ce to build native 2D games in NativeScript 👾", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-phaser/package.json b/packages/canvas-phaser/package.json index 467e1701f..9e92f7ec1 100644 --- a/packages/canvas-phaser/package.json +++ b/packages/canvas-phaser/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-phaser", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Build awesome 2D games with Phaser.js and NativeScript", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-pixi/package.json b/packages/canvas-pixi/package.json index 5634b5713..f83e31583 100644 --- a/packages/canvas-pixi/package.json +++ b/packages/canvas-pixi/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-pixi", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Plugin for using pixi.js in NativeScript", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-polyfill/package.json b/packages/canvas-polyfill/package.json index 6b781ceb6..b1a8dafca 100644 --- a/packages/canvas-polyfill/package.json +++ b/packages/canvas-polyfill/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-polyfill", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Polyfill for making NativeScript compatible with web libs like pixi.js, three.js, phaser.js, babylon.js, etc....", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas-three/package.json b/packages/canvas-three/package.json index 34f07d97f..412cf7e35 100644 --- a/packages/canvas-three/package.json +++ b/packages/canvas-three/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas-three", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "Utilities for using THREE.js on NativeScript", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas/package.json b/packages/canvas/package.json index 281637a51..121297bae 100644 --- a/packages/canvas/package.json +++ b/packages/canvas/package.json @@ -1,6 +1,6 @@ { "name": "@nativescript/canvas", - "version": "2.0.0-alpha.48", + "version": "2.0.0-alpha.49", "description": "DOM Canvas API for NativeScript", "main": "index", "typings": "index.d.ts", diff --git a/packages/canvas/platforms/android/canvas-release.aar b/packages/canvas/platforms/android/canvas-release.aar index 2183887db..182e0c72e 100644 Binary files a/packages/canvas/platforms/android/canvas-release.aar and b/packages/canvas/platforms/android/canvas-release.aar differ diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist b/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist index 803c127dd..2552f82e9 100644 --- a/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist +++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist @@ -8,32 +8,32 @@ DebugSymbolsPath dSYMs LibraryIdentifier - ios-arm64 + ios-arm64_x86_64-simulator LibraryPath CanvasNative.framework SupportedArchitectures arm64 + x86_64 SupportedPlatform ios + SupportedPlatformVariant + simulator DebugSymbolsPath dSYMs LibraryIdentifier - ios-arm64_x86_64-simulator + ios-arm64 LibraryPath CanvasNative.framework SupportedArchitectures arm64 - x86_64 SupportedPlatform ios - SupportedPlatformVariant - simulator CFBundlePackageType diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative index 909b172d9..c89d31b36 100755 Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h index f799a4a91..b12b4557b 100644 --- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h +++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative index b7670f395..781f4f6c5 100644 Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative index 90dc866f2..192876b17 100755 Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h index f799a4a91..b12b4557b 100644 --- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h +++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources index a1e2d592d..8e4eb9030 100644 --- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources +++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources @@ -18,7 +18,7 @@ Headers/canvas_native.h - pRAw58hbawyHmNg47MpPInfGUXE= + OGCSEenyrzd3RyVAV445VyaSuSQ= Info.plist @@ -108,7 +108,7 @@ hash2 - +uJrcducrhwiNwtZ6wBUM2xpn2cfp1O2gq8/4NtuBVU= + 4ynTl1zPCBzVAd/oTD4NPvJlB6B79gIJMszZCwNazPg= Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative index 18fddfa1a..0e12c1e18 100644 Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ diff --git a/packages/canvas/platforms/ios/Podfile b/packages/canvas/platforms/ios/Podfile index ff271c856..154aa3375 100644 --- a/packages/canvas/platforms/ios/Podfile +++ b/packages/canvas/platforms/ios/Podfile @@ -1,4 +1,4 @@ -platform :ios, '11.0' +platform :ios, '12.0' #pod 'CanvasNative' , '~> 1.0.0.alpha.11' #pod 'CanvasNative', :path => "$(SRCROOT)/../../../../../" #pod 'CanvasNative', :git => 'https://github.com/NativeScript/canvas.git', :tag => '1.0.0-alpha.2' diff --git a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp index 3301de800..643d8d32f 100644 --- a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp +++ b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp @@ -6,7 +6,7 @@ #include "Helpers.h" #include "Caches.h" -CanvasPattern::CanvasPattern(PaintStyle* style) : style_(style) {} +CanvasPattern::CanvasPattern(PaintStyle *style) : style_(style) {} void CanvasPattern::Init(const v8::Local &canvasModule, v8::Isolate *isolate) { v8::Locker locker(isolate); @@ -20,6 +20,9 @@ void CanvasPattern::Init(const v8::Local &canvasModule, v8::Isolate canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func); } +v8::CFunction CanvasPattern::fast_set_transform_( + v8::CFunction::Make(CanvasPattern::FastSetTransform)); + CanvasPattern *CanvasPattern::GetPointer(const v8::Local &object) { auto ptr = object->GetAlignedPointerFromInternalField(0); if (ptr == nullptr) { @@ -33,7 +36,7 @@ static v8::Local NewInstance(v8::Isolate *isolate, CanvasPattern *pa v8::EscapableHandleScope scope(isolate); auto object = CanvasPattern::GetCtor(isolate)->GetFunction( context).ToLocalChecked()->NewInstance(context).ToLocalChecked(); - SetNativeType( object, NativeType::CanvasPattern); + SetNativeType(object, NativeType::CanvasPattern); object->SetAlignedPointerInInternalField(0, pattern); return scope.Escape(object); } @@ -51,9 +54,9 @@ v8::Local CanvasPattern::GetCtor(v8::Isolate *isolate) { auto tmpl = ctorTmpl->InstanceTemplate(); tmpl->SetInternalFieldCount(2); - tmpl->Set( - ConvertToV8String(isolate, "SetTransform"), - v8::FunctionTemplate::New(isolate, &SetTransform)); + + SetFastMethod(isolate, tmpl, "setTransform", SetTransform, &fast_set_transform_, + v8::Local()); cache->CanvasPatternTmpl = std::make_unique>(isolate, ctorTmpl); @@ -67,7 +70,7 @@ void CanvasPattern::SetTransform(const v8::FunctionCallbackInfo &args } auto value = args[0]; - auto type = GetNativeType( value); + auto type = GetNativeType(value); if (type == NativeType::Matrix) { @@ -81,6 +84,6 @@ void CanvasPattern::SetTransform(const v8::FunctionCallbackInfo &args } -PaintStyle* CanvasPattern::GetPaintStyle() { +PaintStyle *CanvasPattern::GetPaintStyle() { return this->style_; } diff --git a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.h b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.h index 4ace7b717..896d876a4 100644 --- a/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.h +++ b/packages/canvas/platforms/ios/src/cpp/canvas2d/CanvasPattern.h @@ -3,20 +3,23 @@ // #pragma once + #include "MatrixImpl.h" #include #include "ObjectWrapperImpl.h" -class CanvasPattern: ObjectWrapperImpl { +class CanvasPattern : ObjectWrapperImpl { public: - CanvasPattern(PaintStyle* style); + CanvasPattern(PaintStyle *style); ~CanvasPattern() { canvas_native_paint_style_destroy(this->GetPaintStyle()); this->style_ = nullptr; } - PaintStyle* GetPaintStyle(); + PaintStyle *GetPaintStyle(); + + static v8::CFunction fast_set_transform_; static void Init(const v8::Local &canvasModule, v8::Isolate *isolate); @@ -27,7 +30,7 @@ class CanvasPattern: ObjectWrapperImpl { v8::EscapableHandleScope scope(isolate); auto object = CanvasPattern::GetCtor(isolate)->GetFunction( context).ToLocalChecked()->NewInstance(context).ToLocalChecked(); - SetNativeType( object, NativeType::CanvasPattern); + SetNativeType(object, NativeType::CanvasPattern); object->SetAlignedPointerInInternalField(0, pattern); pattern->BindFinalizer(isolate, object); return scope.Escape(object); @@ -37,7 +40,27 @@ class CanvasPattern: ObjectWrapperImpl { static void SetTransform(const v8::FunctionCallbackInfo &args); + static void + FastSetTransform(v8::Local receiver_obj, v8::Local matrix_obj) { + CanvasPattern *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto type = GetNativeType(matrix_obj); + + if (type == NativeType::Matrix) { + auto matrix = MatrixImpl::GetPointer(matrix_obj); + if (matrix != nullptr) { + canvas_native_pattern_set_transform( + ptr->GetPaintStyle(), + matrix->GetMatrix()); + } + } + + } + private: - PaintStyle* style_; + PaintStyle *style_; }; diff --git a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp index 6c14466c1..6f54dc966 100644 --- a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp +++ b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp @@ -5,6 +5,17 @@ #include "WebGLRenderingContext.h" #include "OneByteStringResource.h" +v8::CFunction WebGLRenderingContext::fast_disable_( + v8::CFunction::Make(WebGLRenderingContext::FastDisable)); + +v8::CFunction WebGLRenderingContext::fast_resized_( + v8::CFunction::Make(WebGLRenderingContext::__FastResized)); + +v8::CFunction WebGLRenderingContext::fast_start_raf_( + v8::CFunction::Make(WebGLRenderingContext::__FastStartRaf)); + +v8::CFunction WebGLRenderingContext::fast_stop_raf_( + v8::CFunction::Make(WebGLRenderingContext::__FastStopRaf)); v8::CFunction WebGLRenderingContext::fast_active_texture_( v8::CFunction::Make(WebGLRenderingContext::FastActiveTexture)); @@ -57,6 +68,12 @@ v8::CFunction WebGLRenderingContext::fast_uniform4i_( v8::CFunction WebGLRenderingContext::fast_draw_arrays_( v8::CFunction::Make(WebGLRenderingContext::FastDrawArrays)); +v8::CFunction WebGLRenderingContext::fast_clear_depth_( + v8::CFunction::Make(WebGLRenderingContext::FastClearDepth)); + +v8::CFunction WebGLRenderingContext::fast_clear_stencil_( + v8::CFunction::Make(WebGLRenderingContext::FastClearStencil)); + v8::CFunction WebGLRenderingContext::fast_clear_( v8::CFunction::Make(WebGLRenderingContext::FastClear)); @@ -210,7 +227,7 @@ const v8::CFunction uniform_4fv_overloads_[] = { WebGLRenderingContext::fast_uniform_4fv_array_ }; -v8::CFunction WebGLRenderingContext::fast_vertex_attrib_pointer( +v8::CFunction WebGLRenderingContext::fast_vertex_attrib_pointer_( v8::CFunction::Make(WebGLRenderingContext::FastVertexAttribPointer)); @@ -278,6 +295,162 @@ v8::CFunction WebGLRenderingContext::fast_vertex_attrib_4fv_( v8::CFunction::Make(WebGLRenderingContext::FastVertexAttrib4fv)); +v8::CFunction WebGLRenderingContext::fast_blend_color_( + v8::CFunction::Make(WebGLRenderingContext::FastBlendColor)); + +v8::CFunction WebGLRenderingContext::fast_blend_equation_separate_( + v8::CFunction::Make(WebGLRenderingContext::FastBlendEquationSeparate)); + +v8::CFunction WebGLRenderingContext::fast_blend_equation_( + v8::CFunction::Make(WebGLRenderingContext::FastBlendEquation)); + +v8::CFunction WebGLRenderingContext::fast_blend_func_separate_( + v8::CFunction::Make(WebGLRenderingContext::FastBlendFuncSeparate)); + +v8::CFunction WebGLRenderingContext::fast_blend_func_( + v8::CFunction::Make(WebGLRenderingContext::FastBlendFunc)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_data_os_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataOS)); + +v8::CFunction WebGLRenderingContext::fast_buffer_data_target_usage_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataTargetUsage)); + + +/* + v8::CFunction WebGLRenderingContext::fast_buffer_data_u8_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataU8)); + +v8::CFunction WebGLRenderingContext::fast_buffer_data_i8_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataI8)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_data_u16_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataU16)); + +v8::CFunction WebGLRenderingContext::fast_buffer_data_i16_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataI16)); +*/ + + +v8::CFunction WebGLRenderingContext::fast_buffer_data_u32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataU32)); + +v8::CFunction WebGLRenderingContext::fast_buffer_data_i32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataI32)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_data_f32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataF32)); + +v8::CFunction WebGLRenderingContext::fast_buffer_data_f64_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferDataF64)); +// +//v8::CFunction WebGLRenderingContext::fast_buffer_data_array_buffer_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferDataArrayBuffer)); + + +const v8::CFunction fast_buffer_data_overloads_[] = { + WebGLRenderingContext::fast_buffer_data_os_, + //WebGLRenderingContext::fast_buffer_data_u8_, +// WebGLRenderingContext::fast_buffer_data_i8_, +// WebGLRenderingContext::fast_buffer_data_u16_, +// WebGLRenderingContext::fast_buffer_data_i16_, + WebGLRenderingContext::fast_buffer_data_u32_, + WebGLRenderingContext::fast_buffer_data_i32_, + WebGLRenderingContext::fast_buffer_data_f32_, + WebGLRenderingContext::fast_buffer_data_f64_, + // WebGLRenderingContext::fast_buffer_data_array_buffer_, + WebGLRenderingContext::fast_buffer_data_target_usage_, +}; + + +v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_target_offset_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataTargetOffset)); + +//v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_u8_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataU8)); + + +//v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_i8_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataI8)); +// +//v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_u16_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataU16)); +// +// +//v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_i16_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataI16)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_u32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataU32)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_i32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataI32)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_f32_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataF32)); + + +v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_f64_( + v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataF64)); + + +//v8::CFunction WebGLRenderingContext::fast_buffer_sub_data_array_buffer_( +// v8::CFunction::Make(WebGLRenderingContext::FastBufferSubDataArrayBuffer)); + + + +const v8::CFunction fast_buffer_sub_data_overloads_[] = { + // WebGLRenderingContext::fast_buffer_sub_data_u8_, + WebGLRenderingContext::fast_buffer_sub_data_u32_, + WebGLRenderingContext::fast_buffer_sub_data_i32_, + WebGLRenderingContext::fast_buffer_sub_data_f32_, + WebGLRenderingContext::fast_buffer_sub_data_f64_, + // WebGLRenderingContext::fast_buffer_sub_data_array_buffer_, + WebGLRenderingContext::fast_buffer_sub_data_target_offset_ +}; + + +v8::CFunction WebGLRenderingContext::fast_check_framebuffer_status_( + v8::CFunction::Make(WebGLRenderingContext::FastCheckFramebufferStatus)); + +v8::CFunction WebGLRenderingContext::fast_validate_program_( + v8::CFunction::Make(WebGLRenderingContext::FastValidateProgram)); + + +v8::CFunction WebGLRenderingContext::fast_delete_buffer_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteBuffer)); + + +v8::CFunction WebGLRenderingContext::fast_delete_buffer_framebuffer_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteFramebuffer)); + +v8::CFunction WebGLRenderingContext::fast_delete_program_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteProgram)); + + +v8::CFunction WebGLRenderingContext::fast_delete_renderbuffer_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteFramebuffer)); + +v8::CFunction WebGLRenderingContext::fast_delete_shader_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteFramebuffer)); + +v8::CFunction WebGLRenderingContext::fast_delete_texture_( + v8::CFunction::Make(WebGLRenderingContext::FastDeleteTexture)); + + +v8::CFunction WebGLRenderingContext::fast_compile_shader_( + v8::CFunction::Make(WebGLRenderingContext::FastCompileShader)); + +v8::CFunction WebGLRenderingContext::fast_framebuffer_texture_2d_( + v8::CFunction::Make(WebGLRenderingContext::FastFramebufferTexture2D)); + + WebGLRenderingContext::WebGLRenderingContext(WebGLState *state) : WebGLRenderingContextBase(state, WebGLRenderingVersion::V1) { @@ -1544,6 +1717,7 @@ void WebGLRenderingContext::CullFace(const v8::FunctionCallbackInfo & } + void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo &args) { WebGLRenderingContext *ptr = GetPointer(args.This()); if (ptr == nullptr) { @@ -5987,21 +6161,26 @@ void WebGLRenderingContext::SetProps(v8::Isolate *isolate, void WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local &tmpl) { - tmpl->Set(ConvertToV8String(isolate, "__resized"), - v8::FunctionTemplate::New(isolate, &__Resized)); - tmpl->Set(ConvertToV8String(isolate, "__startRaf"), - v8::FunctionTemplate::New(isolate, &__StartRaf)); - tmpl->Set(ConvertToV8String(isolate, "__stopRaf"), - v8::FunctionTemplate::New(isolate, &__StopRaf)); + SetFastMethod(isolate, tmpl, "__resized", __Resized, &fast_resized_, + v8::Local()); + + SetFastMethod(isolate, tmpl, "__startRaf", __StartRaf, &fast_start_raf_, + v8::Local()); + + SetFastMethod(isolate, tmpl, "__stopRaf", __StopRaf, &fast_stop_raf_, + v8::Local()); + + + // todo tmpl->Set(ConvertToV8String(isolate, "__toDataURL"), v8::FunctionTemplate::New(isolate, &__ToDataURL)); + // todo tmpl->Set(ConvertToV8String(isolate, "__getSupportedExtensions"), v8::FunctionTemplate::New(isolate, &__GetSupportedExtensions)); - SetFastMethod(isolate, tmpl, "activeTexture", ActiveTexture, &fast_active_texture_, v8::Local()); @@ -6009,6 +6188,7 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); + // todo tmpl->Set( ConvertToV8String(isolate, "bindAttribLocation"), v8::FunctionTemplate::New(isolate, &BindAttribLocation) @@ -6017,90 +6197,58 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); - - SetFastMethodWithOverLoads(isolate, tmpl, "bindFramebuffer", BindFramebuffer, fast_bind_frame_buffer_overloads_, v8::Local()); - - SetFastMethodWithOverLoads(isolate, tmpl, "bindRenderbuffer", BindRenderbuffer, fast_bind_render_buffer_overloads_, v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "bindTexture"), - v8::FunctionTemplate::New(isolate, &BindTexture) - ); - SetFastMethodWithOverLoads(isolate, tmpl, "bindTexture", BindTexture, fast_bind_texture_overloads_, v8::Local()); + SetFastMethod(isolate, tmpl, "blendColor", BlendColor, &fast_blend_color_, + v8::Local()); + SetFastMethod(isolate, tmpl, "blendEquationSeparate", BlendEquationSeparate, + &fast_blend_equation_separate_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "blendColor"), - v8::FunctionTemplate::New(isolate, &BlendColor) - ); + SetFastMethod(isolate, tmpl, "blendEquation", BlendEquation, &fast_blend_equation_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "blendEquationSeparate"), - v8::FunctionTemplate::New(isolate, &BlendEquationSeparate) - ); - tmpl->Set( - ConvertToV8String(isolate, "blendEquation"), - v8::FunctionTemplate::New(isolate, &BlendEquation) - ); + SetFastMethod(isolate, tmpl, "blendFuncSeparate", BlendFuncSeparate, &fast_blend_func_separate_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "blendFuncSeparate"), - v8::FunctionTemplate::New(isolate, &BlendFuncSeparate) - ); + SetFastMethod(isolate, tmpl, "blendFunc", BlendFunc, &fast_blend_func_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "blendFunc"), - v8::FunctionTemplate::New(isolate, &BlendFunc) - ); - tmpl->Set( - ConvertToV8String(isolate, "bufferData"), - v8::FunctionTemplate::New(isolate, &BufferData) - ); + SetFastMethodWithOverLoads(isolate, tmpl, "bufferData", BufferData, + fast_buffer_data_overloads_, v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "bufferSubData"), - v8::FunctionTemplate::New(isolate, &BufferSubData) - ); - tmpl->Set( - ConvertToV8String(isolate, "checkFramebufferStatus"), - v8::FunctionTemplate::New(isolate, &CheckFramebufferStatus) - ); + SetFastMethodWithOverLoads(isolate, tmpl, "bufferSubData", BufferSubData, + fast_buffer_sub_data_overloads_, v8::Local()); + + + SetFastMethod(isolate, tmpl, "checkFramebufferStatus", CheckFramebufferStatus, + &fast_check_framebuffer_status_, + v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "clearColor"), -// v8::FunctionTemplate::New(isolate, &ClearColor) -// ); SetFastMethod(isolate, tmpl, "clearColor", ClearColor, &fast_clear_color_, v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "clearDepth"), - v8::FunctionTemplate::New(isolate, &ClearDepth) - ); - tmpl->Set( - ConvertToV8String(isolate, "clearStencil"), - v8::FunctionTemplate::New(isolate, &ClearStencil) - ); + SetFastMethod(isolate, tmpl, "clearDepth", ClearDepth, &fast_clear_depth_, + v8::Local()); + -// tmpl->Set( -// ConvertToV8String(isolate, "clear"), -// v8::FunctionTemplate::New(isolate, &Clear) -// ); + SetFastMethod(isolate, tmpl, "clearStencil", ClearStencil, &fast_clear_stencil_, + v8::Local()); SetFastMethod(isolate, tmpl, "clear", Clear, &fast_clear_, v8::Local()); @@ -6113,10 +6261,11 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::LocalSet( - ConvertToV8String(isolate, "compileShader"), - v8::FunctionTemplate::New(isolate, &CompileShader) - ); + + SetFastMethod(isolate, tmpl, "compileShader", CompileShader, &fast_compile_shader_, + v8::Local()); + + tmpl->Set( ConvertToV8String(isolate, "compressedTexImage2D"), v8::FunctionTemplate::New(isolate, &CompressedTexImage2D) @@ -6170,36 +6319,25 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::LocalSet( - ConvertToV8String(isolate, "deleteBuffer"), - v8::FunctionTemplate::New(isolate, &DeleteBuffer) - ); + SetFastMethod(isolate, tmpl, "deleteBuffer", DeleteBuffer, &fast_delete_buffer_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "deleteFramebuffer"), - v8::FunctionTemplate::New(isolate, &DeleteFramebuffer) - ); + SetFastMethod(isolate, tmpl, "deleteFramebuffer", DeleteFramebuffer, + &fast_delete_buffer_framebuffer_, v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "deleteProgram"), - v8::FunctionTemplate::New(isolate, &DeleteProgram) - ); + SetFastMethod(isolate, tmpl, "deleteProgram", DeleteProgram, &fast_delete_program_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "deleteRenderbuffer"), - v8::FunctionTemplate::New(isolate, &DeleteRenderbuffer) - ); + SetFastMethod(isolate, tmpl, "deleteRenderbuffer", DeleteRenderbuffer, + &fast_delete_renderbuffer_, v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "deleteShader"), - v8::FunctionTemplate::New(isolate, &DeleteShader) - ); + SetFastMethod(isolate, tmpl, "deleteShader", DeleteShader, &fast_delete_shader_, + v8::Local()); + + SetFastMethod(isolate, tmpl, "deleteTexture", DeleteTexture, &fast_delete_texture_, + v8::Local()); - tmpl->Set( - ConvertToV8String(isolate, "deleteTexture"), - v8::FunctionTemplate::New(isolate, &DeleteTexture) - ); tmpl->Set( ConvertToV8String(isolate, "depthFunc"), @@ -6226,37 +6364,20 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::LocalSet( - ConvertToV8String(isolate, "disable"), - v8::FunctionTemplate::New(isolate, &Disable) - ); - - -// tmpl->Set( -// ConvertToV8String(isolate, "drawArrays"), -// v8::FunctionTemplate::New(isolate, &DrawArrays) -// ); + SetFastMethod(isolate, tmpl, "disable", Disable, &fast_disable_, + v8::Local()); SetFastMethod(isolate, tmpl, "drawArrays", DrawArrays, &fast_draw_arrays_, v8::Local()); - SetFastMethod(isolate, tmpl, "drawElements", DrawElements, &fast_draw_elements_, v8::Local()); - - SetFastMethod(isolate, tmpl, "enableVertexAttribArray", EnableVertexAttribArray, &fast_enable_vertex_attrib_array_, v8::Local()); - -// tmpl->Set( -// ConvertToV8String(isolate, "enable"), -// v8::FunctionTemplate::New(isolate, &Enable) -// ); - SetFastMethod(isolate, tmpl, "enable", Enable, &fast_enable_, v8::Local()); tmpl->Set( @@ -6269,16 +6390,15 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::LocalSet( ConvertToV8String(isolate, "framebufferRenderbuffer"), v8::FunctionTemplate::New(isolate, &FramebufferRenderbuffer) ); - tmpl->Set( - ConvertToV8String(isolate, "framebufferTexture2D"), - v8::FunctionTemplate::New(isolate, &FramebufferTexture2D) - ); + + SetFastMethod(isolate, tmpl, "framebufferTexture2D", FramebufferTexture2D, + &fast_framebuffer_texture_2d_, v8::Local()); + tmpl->Set( ConvertToV8String(isolate, "frontFace"), @@ -6595,7 +6715,7 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); + &fast_vertex_attrib_pointer_, v8::Local()); SetFastMethod(isolate, tmpl, "uniform1f", Uniform1f, &fast_uniform1f_, v8::Local()); @@ -6605,7 +6725,6 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); - SetFastMethodWithOverLoads(isolate, tmpl, "uniform1fv", Uniform1fv, uniform_1fv_overloads_, v8::Local()); @@ -6613,7 +6732,6 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); - SetFastMethod(isolate, tmpl, "uniform2f", Uniform2f, &fast_uniform2f_, v8::Local()); @@ -6625,97 +6743,39 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); - SetFastMethod(isolate, tmpl, "uniform2i", Uniform2i, &fast_uniform2i_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform3f"), -// v8::FunctionTemplate::New(isolate, &Uniform3f) -// ); SetFastMethod(isolate, tmpl, "uniform3f", Uniform3f, &fast_uniform3f_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform3iv"), -// v8::FunctionTemplate::New(isolate, &Uniform3iv) -// ); SetFastMethodWithOverLoads(isolate, tmpl, "uniform3iv", Uniform3iv, uniform_3iv_overloads_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform3fv"), -// v8::FunctionTemplate::New(isolate, &Uniform3fv) -// ); SetFastMethodWithOverLoads(isolate, tmpl, "uniform3fv", Uniform3fv, uniform_3fv_overloads_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform3i"), -// v8::FunctionTemplate::New(isolate, &Uniform3i) -// ); - SetFastMethod(isolate, tmpl, "uniform3i", Uniform3i, &fast_uniform3i_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform4f"), -// v8::FunctionTemplate::New(isolate, &Uniform4f) -// ); SetFastMethod(isolate, tmpl, "uniform4f", Uniform4f, &fast_uniform4f_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform4iv"), -// v8::FunctionTemplate::New(isolate, &Uniform4iv) -// ); - SetFastMethodWithOverLoads(isolate, tmpl, "uniform4iv", Uniform4iv, uniform_4iv_overloads_, v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "uniform4fv"), -// v8::FunctionTemplate::New(isolate, &Uniform4fv) -// ); - - SetFastMethodWithOverLoads(isolate, tmpl, "uniform4fv", Uniform4fv, uniform_4fv_overloads_, v8::Local()); - -// tmpl->Set( -// ConvertToV8String(isolate, "uniform4i"), -// v8::FunctionTemplate::New(isolate, &Uniform4i) -// ); - SetFastMethod(isolate, tmpl, "uniform4i", Uniform4i, &fast_uniform4i_, v8::Local()); - -// tmpl->Set( -// ConvertToV8String(isolate, "uniformMatrix2fv"), -// v8::FunctionTemplate::New(isolate, &UniformMatrix2fv) -// ); - SetFastMethodWithOverLoads(isolate, tmpl, "uniformMatrix2fv", UniformMatrix2fv, uniform_matrix2fv_overloads_, v8::Local()); - -// tmpl->Set( -// ConvertToV8String(isolate, "uniformMatrix3fv"), -// v8::FunctionTemplate::New(isolate, &UniformMatrix3fv) -// ); - - SetFastMethodWithOverLoads(isolate, tmpl, "uniformMatrix3fv", UniformMatrix3fv, uniform_matrix3fv_overloads_, v8::Local()); - -// tmpl->Set( -// ConvertToV8String(isolate, "uniformMatrix4fv"), -// v8::FunctionTemplate::New(isolate, &UniformMatrix4fv) -// ); - SetFastMethodWithOverLoads(isolate, tmpl, "uniformMatrix4fv", UniformMatrix4fv, uniform_matrix4fv_overloads_, v8::Local()); @@ -6723,22 +6783,8 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local()); -// tmpl->Set( -// ConvertToV8String(isolate, "useProgram"), -// v8::FunctionTemplate::New(isolate, &UseProgram) -// ); - - - tmpl->Set( - ConvertToV8String(isolate, "validateProgram"), - v8::FunctionTemplate::New(isolate, &ValidateProgram) - ); - - -// tmpl->Set( -// ConvertToV8String(isolate, "viewport"), -// v8::FunctionTemplate::New(isolate, &Viewport) -// ); + SetFastMethod(isolate, tmpl, "validateProgram", ValidateProgram, &fast_validate_program_, + v8::Local()); SetFastMethod(isolate, tmpl, "viewport", Viewport, &fast_viewport_, v8::Local()); diff --git a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.h b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.h index 626ebe8bb..d4258cd47 100644 --- a/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.h +++ b/packages/canvas/platforms/ios/src/cpp/webgl/WebGLRenderingContext.h @@ -66,6 +66,12 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static v8::Local GetCtor(v8::Isolate *isolate); + static v8::CFunction fast_resized_; + + static v8::CFunction fast_start_raf_; + + static v8::CFunction fast_stop_raf_; + static v8::CFunction fast_active_texture_; static v8::CFunction fast_attach_shader_; @@ -86,6 +92,42 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static v8::CFunction fast_bind_texture_null_; + static v8::CFunction fast_blend_color_; + static v8::CFunction fast_blend_equation_separate_; + static v8::CFunction fast_blend_equation_; + static v8::CFunction fast_blend_func_separate_; + static v8::CFunction fast_blend_func_; + + static v8::CFunction fast_buffer_data_os_; + static v8::CFunction fast_buffer_data_target_usage_; + static v8::CFunction fast_buffer_data_u8_; + static v8::CFunction fast_buffer_data_i8_; + static v8::CFunction fast_buffer_data_u16_; + static v8::CFunction fast_buffer_data_i16_; + static v8::CFunction fast_buffer_data_u32_; + static v8::CFunction fast_buffer_data_i32_; + static v8::CFunction fast_buffer_data_f32_; + static v8::CFunction fast_buffer_data_f64_; + static v8::CFunction fast_buffer_data_array_buffer_; + + static v8::CFunction fast_buffer_sub_data_target_offset_; + + static v8::CFunction fast_buffer_sub_data_u8_; + static v8::CFunction fast_buffer_sub_data_i8_; + + static v8::CFunction fast_buffer_sub_data_u16_; + static v8::CFunction fast_buffer_sub_data_i16_; + + static v8::CFunction fast_buffer_sub_data_u32_; + static v8::CFunction fast_buffer_sub_data_i32_; + + static v8::CFunction fast_buffer_sub_data_f32_; + static v8::CFunction fast_buffer_sub_data_f64_; + + static v8::CFunction fast_buffer_sub_data_array_buffer_; + + static v8::CFunction fast_check_framebuffer_status_; + static v8::CFunction fast_draw_elements_; static v8::CFunction fast_vertex_attrib_1f_; @@ -121,6 +163,10 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static v8::CFunction fast_uniform4i_; + static v8::CFunction fast_clear_depth_; + + static v8::CFunction fast_clear_stencil_; + static v8::CFunction fast_clear_; static v8::CFunction fast_clear_color_; @@ -181,8 +227,24 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static v8::CFunction fast_uniform_4iv_array_; - static v8::CFunction fast_vertex_attrib_pointer; + static v8::CFunction fast_vertex_attrib_pointer_; + static v8::CFunction fast_validate_program_; + + static v8::CFunction fast_delete_buffer_; + + static v8::CFunction fast_delete_buffer_framebuffer_; + + static v8::CFunction fast_delete_program_; + static v8::CFunction fast_delete_renderbuffer_; + static v8::CFunction fast_delete_shader_; + static v8::CFunction fast_delete_texture_; + + static v8::CFunction fast_disable_; + + static v8::CFunction fast_compile_shader_; + + static v8::CFunction fast_framebuffer_texture_2d_; static v8::Local @@ -223,10 +285,41 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void __Resized(const v8::FunctionCallbackInfo &args); + static void __FastResized(v8::Local receiver_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_resized( + ptr->GetState()); + + } + static void __StartRaf(const v8::FunctionCallbackInfo &args); + static void __FastStartRaf(v8::Local receiver_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + ptr->StartRaf(); + + } + static void __StopRaf(const v8::FunctionCallbackInfo &args); + static void __FastStopRaf(v8::Local receiver_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + ptr->StopRaf(); + + } + static void ActiveTexture(const v8::FunctionCallbackInfo &args); @@ -457,20 +550,506 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void BlendColor(const v8::FunctionCallbackInfo &args); + static void + FastBlendColor(v8::Local receiver_obj, double red, double green, double blue, + double alpha) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_blend_color( + static_cast(red), + static_cast(green), + static_cast(blue), + static_cast(alpha), + ptr->GetState() + ); + } + static void BlendEquationSeparate(const v8::FunctionCallbackInfo &args); + static void FastBlendEquationSeparate(v8::Local receiver_obj, uint32_t modeRGB, + uint32_t modeAlpha) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_blend_equation_separate( + modeRGB, + modeAlpha, + ptr->GetState() + ); + } + static void BlendEquation(const v8::FunctionCallbackInfo &args); + static void FastBlendEquation(v8::Local receiver_obj, uint32_t mode) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + canvas_native_webgl_blend_equation( + mode, + ptr->GetState() + ); + } + static void BlendFuncSeparate(const v8::FunctionCallbackInfo &args); + static void + FastBlendFuncSeparate(v8::Local receiver_obj, uint32_t srcRGB, uint32_t dstRGB, + uint32_t srcAlpha, uint32_t dstAlpha) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_blend_func_separate( + srcRGB, + dstRGB, + srcAlpha, + dstAlpha, + ptr->GetState() + ); + } + static void BlendFunc(const v8::FunctionCallbackInfo &args); + static void + FastBlendFunc(v8::Local receiver_obj, uint32_t sfactor, uint32_t dfactor) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_blend_func( + sfactor, + dfactor, + ptr->GetState() + ); + } + static void BufferData(const v8::FunctionCallbackInfo &args); + + static void + FastBufferDataTargetUsage(v8::Local receiver_obj, uint32_t target, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_buffer_data_none( + target, + 0, + usage, + ptr->GetState() + ); + } + + /* + * + static void FastBufferDataU8(v8::Local receiver_obj, uint32_t target, + const v8::FastApiArrayBufferView &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + canvas_native_webgl_buffer_data( + target, + (uint8_t *) srcData.data, srcData.byte_length, + usage, + ptr->GetState() + ); + } + + + static void FastBufferDataI8(v8::Local receiver_obj, uint32_t target, + const v8::FastApiArrayBufferView &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_buffer_data_i8( + target, + (int8_t *)srcData.data, srcData.byte_length, + usage, + ptr->GetState() + ); + } + + static void FastBufferDataU16(v8::Local receiver_obj, uint32_t target, + const v8::FastApiArrayBufferView &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_buffer_data_u16( + target, + (uint16_t *)srcData.data, srcData.byte_length / sizeof(uint16_t), + usage, + ptr->GetState() + ); + } + + static void FastBufferDataI16(v8::Local receiver_obj, uint32_t target, + const v8::FastApiArrayBufferView &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + canvas_native_webgl_buffer_data_i16( + target, + (int16_t *)srcData.data, srcData.byte_length / sizeof(int16_t), + usage, + ptr->GetState() + ); + } + + */ + + static void FastBufferDataF32(v8::Local receiver_obj, uint32_t target, + const v8::FastApiTypedArray &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + float *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_data_f32( + target, + data, size, + usage, + ptr->GetState() + ); + } + + static void FastBufferDataF64(v8::Local receiver_obj, uint32_t target, + const v8::FastApiTypedArray &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + double *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_data_f64( + target, + data, size, + usage, + ptr->GetState() + ); + } + + static void FastBufferDataU32(v8::Local receiver_obj, uint32_t target, + const v8::FastApiTypedArray &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + uint32_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_data_u32( + target, + data, size, + usage, + ptr->GetState() + ); + } + + static void FastBufferDataI32(v8::Local receiver_obj, uint32_t target, + const v8::FastApiTypedArray &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + int32_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_data_i32( + target, + data, size, + usage, + ptr->GetState() + ); + } + + static void FastBufferDataArrayBuffer(v8::Local receiver_obj, uint32_t target, + const v8::FastApiArrayBuffer &srcData, uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + canvas_native_webgl_buffer_data( + target, + (uint8_t *) srcData.data, srcData.byte_length, + usage, + ptr->GetState() + ); + } + + static void + FastBufferDataOS(v8::Local receiver_obj, uint32_t target, uint32_t offset, + uint32_t usage) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + canvas_native_webgl_buffer_data_none( + target, + static_cast(offset), + usage, + ptr->GetState() + ); + } + static void BufferSubData(const v8::FunctionCallbackInfo &args); + static void FastBufferSubDataTargetOffset(v8::Local receiver_obj, uint32_t target, + int32_t offset) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_buffer_sub_data_none( + target, + static_cast(offset), + ptr->GetState() + ); + } + + /* + static void + FastBufferSubDataU8(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiArrayBufferView &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + canvas_native_webgl_buffer_sub_data( + target, + static_cast(offset), + (uint8_t *) srcData.data, srcData.byte_length, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataI8(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiArrayBufferView &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + int8_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_i8( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataU16(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiArrayBufferView &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + uint16_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_u16( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataI16(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiArrayBufferView&srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + int16_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_i16( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + */ + static void + FastBufferSubDataU32(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiTypedArray &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + uint32_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_u32( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataI32(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiTypedArray &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + int32_t *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_i32( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataF32(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiTypedArray &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + float *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_f32( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void + FastBufferSubDataF64(v8::Local receiver_obj, uint32_t target, int32_t offset, + const v8::FastApiTypedArray &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto size = srcData.length(); + double *data; + srcData.getStorageIfAligned(&data); + + + canvas_native_webgl_buffer_sub_data_f64( + target, + static_cast(offset), + data, size, + ptr->GetState() + ); + } + + + static void FastBufferSubDataArrayBuffer(v8::Local receiver_obj, uint32_t target, + int32_t offset, + const v8::FastApiArrayBuffer &srcData) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_buffer_sub_data( + target, + static_cast(offset), + (uint8_t *) srcData.data, srcData.byte_length, + ptr->GetState() + ); + } + static void CheckFramebufferStatus(const v8::FunctionCallbackInfo &args); + static uint32_t + FastCheckFramebufferStatus(v8::Local receiver_obj, uint32_t target) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return 0; + } + + return canvas_native_webgl_check_frame_buffer_status( + target, + ptr->GetState() + ); + } + static void ClearColor(const v8::FunctionCallbackInfo &args); static void @@ -499,8 +1078,32 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void ClearDepth(const v8::FunctionCallbackInfo &args); + static void FastClearDepth(v8::Local receiver_obj, double depth) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_clear_depth( + static_cast(depth), + ptr->GetState() + ); + } + static void ClearStencil(const v8::FunctionCallbackInfo &args); + static void FastClearStencil(v8::Local receiver_obj, int32_t stencil) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_clear_stencil( + stencil, + ptr->GetState() + ); + } + static void Clear(const v8::FunctionCallbackInfo &args); static void ClearImpl(WebGLRenderingContext *ptr, uint32_t mask) { @@ -531,6 +1134,25 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void CompileShader(const v8::FunctionCallbackInfo &args); + static void + FastCompileShader(v8::Local receiver_obj, v8::Local shader_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + if (GetNativeType(shader_obj) == NativeType::WebGLShader) { + auto shader = WebGLShader::GetPointer(shader_obj); + if (shader != nullptr) { + canvas_native_webgl_compile_shader( + shader->GetShader(), + ptr->GetState() + ); + } + } + + } + static void CompressedTexImage2D(const v8::FunctionCallbackInfo &args); static void CompressedTexSubImage2D(const v8::FunctionCallbackInfo &args); @@ -555,16 +1177,139 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void DeleteBuffer(const v8::FunctionCallbackInfo &args); + static void FastDeleteBuffer(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + auto type = GetNativeType(value); + if (type == NativeType::WebGLBuffer) { + auto buffer = WebGLBuffer::GetPointer(value); + if (buffer != nullptr) { + canvas_native_webgl_delete_buffer( + buffer->GetBuffer(), + ptr->GetState() + ); + } + } + + } + static void DeleteFramebuffer(const v8::FunctionCallbackInfo &args); + static void + FastDeleteFramebuffer(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto type = GetNativeType(value); + if (type == NativeType::WebGLFramebuffer) { + auto buffer = WebGLFramebuffer::GetPointer(value); + if (buffer != nullptr) { + canvas_native_webgl_delete_framebuffer( + buffer->GetFrameBuffer(), + ptr->GetState() + ); + } + } + + } + static void DeleteProgram(const v8::FunctionCallbackInfo &args); + static void FastDeleteProgram(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto type = GetNativeType(value); + + if (type == NativeType::WebGLProgram) { + auto program = WebGLProgram::GetPointer(value); + if (program != nullptr) { + canvas_native_webgl_delete_framebuffer( + program->GetProgram(), + ptr->GetState() + ); + } + } + + + } + static void DeleteRenderbuffer(const v8::FunctionCallbackInfo &args); + static void + FastDeleteRenderbuffer(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + auto type = GetNativeType(value); + + if (type == NativeType::WebGLRenderbuffer) { + auto buffer = WebGLRenderbuffer::GetPointer(value); + if (buffer != nullptr) { + canvas_native_webgl_delete_renderbuffer( + buffer->GetRenderBuffer(), + ptr->GetState() + ); + } + } + + + } + static void DeleteShader(const v8::FunctionCallbackInfo &args); + static void FastDeleteShader(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + auto type = GetNativeType(value); + + if (type == NativeType::WebGLShader) { + auto shader = WebGLShader::GetPointer(value); + if (shader != nullptr) { + canvas_native_webgl_delete_shader( + shader->GetShader(), + ptr->GetState() + ); + } + } + } + static void DeleteTexture(const v8::FunctionCallbackInfo &args); + static void FastDeleteTexture(v8::Local receiver_obj, v8::Local value) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto type = GetNativeType(value); + + if (type == NativeType::WebGLTexture) { + auto texture = WebGLTexture::GetPointer(value); + if (texture != nullptr) { + canvas_native_webgl_delete_texture( + texture->GetTexture(), + ptr->GetState() + ); + } + } + } + static void DepthFunc(const v8::FunctionCallbackInfo &args); static void DepthMask(const v8::FunctionCallbackInfo &args); @@ -577,6 +1322,18 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void Disable(const v8::FunctionCallbackInfo &args); + static void FastDisable(v8::Local receiver_obj, uint32_t cap) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + canvas_native_webgl_disable( + cap, + ptr->GetState() + ); + } + static void DrawArrays(const v8::FunctionCallbackInfo &args); static void @@ -671,6 +1428,30 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void FramebufferTexture2D(const v8::FunctionCallbackInfo &args); + static void FastFramebufferTexture2D(v8::Local receiver_obj, uint32_t target, + uint32_t attachment, uint32_t textarget, int32_t level, + v8::Local texture_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + auto type = GetNativeType(texture_obj); + if (type == NativeType::WebGLTexture) { + auto texture = WebGLTexture::GetPointer(texture_obj); + if (texture != nullptr) { + canvas_native_webgl_framebuffer_texture2d( + target, + attachment, + textarget, + texture->GetTexture(), + level, + ptr->GetState() + ); + } + } + } + static void FrontFace(const v8::FunctionCallbackInfo &args); static void GenerateMipmap(const v8::FunctionCallbackInfo &args); @@ -1644,6 +2425,27 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void ValidateProgram(const v8::FunctionCallbackInfo &args); + static void + FastValidateProgram(v8::Local receiver_obj, v8::Local program_obj) { + WebGLRenderingContext *ptr = GetPointer(receiver_obj); + if (ptr == nullptr) { + return; + } + + + auto type = GetNativeType(program_obj); + if (type == NativeType::WebGLProgram) { + auto program = WebGLProgram::GetPointer(program_obj); + if (program != nullptr) { + canvas_native_webgl_validate_program( + program->GetProgram(), + ptr->GetState() + ); + } + } + + } + static void VertexAttrib1f(const v8::FunctionCallbackInfo &args); static void FastVertexAttrib1f(v8::Local receiver_obj, uint32_t index, float v0) { @@ -1659,7 +2461,8 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void VertexAttrib1fv(const v8::FunctionCallbackInfo &args); - static void FastVertexAttrib1fv(v8::Local receiver_obj, uint32_t index, const v8::FastApiTypedArray &value) { + static void FastVertexAttrib1fv(v8::Local receiver_obj, uint32_t index, + const v8::FastApiTypedArray &value) { WebGLRenderingContext *ptr = GetPointer(receiver_obj); if (ptr == nullptr) { return; @@ -1692,7 +2495,8 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void VertexAttrib2fv(const v8::FunctionCallbackInfo &args); - static void FastVertexAttrib2fv(v8::Local receiver_obj, uint32_t index, const v8::FastApiTypedArray &value) { + static void FastVertexAttrib2fv(v8::Local receiver_obj, uint32_t index, + const v8::FastApiTypedArray &value) { WebGLRenderingContext *ptr = GetPointer(receiver_obj); if (ptr == nullptr) { return; @@ -1726,7 +2530,8 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void VertexAttrib3fv(const v8::FunctionCallbackInfo &args); - static void FastVertexAttrib3fv(v8::Local receiver_obj, uint32_t index, const v8::FastApiTypedArray &value) { + static void FastVertexAttrib3fv(v8::Local receiver_obj, uint32_t index, + const v8::FastApiTypedArray &value) { WebGLRenderingContext *ptr = GetPointer(receiver_obj); if (ptr == nullptr) { return; @@ -1760,7 +2565,8 @@ class WebGLRenderingContext : public WebGLRenderingContextBase { static void VertexAttrib4fv(const v8::FunctionCallbackInfo &args); - static void FastVertexAttrib4fv(v8::Local receiver_obj, uint32_t index, const v8::FastApiTypedArray &value) { + static void FastVertexAttrib4fv(v8::Local receiver_obj, uint32_t index, + const v8::FastApiTypedArray &value) { WebGLRenderingContext *ptr = GetPointer(receiver_obj); if (ptr == nullptr) { return; diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h index d615bf1d7..d8620dfe4 100644 --- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h +++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h @@ -203,6 +203,10 @@ typedef struct WebGLSync WebGLSync; void canvas_native_image_filter_destroy(struct ImageFilter *value); +void canvas_native_font_add_family(const char *alias, + const char *const *filenames, + uintptr_t length); + void canvas_native_helper_destroy(struct FileHelper *value); struct FileHelper *canvas_native_helper_read_file(const char *path); @@ -244,10 +248,6 @@ void canvas_native_raf_stop(struct Raf *raf); bool canvas_native_raf_get_started(const struct Raf *raf); #endif -void canvas_native_font_add_family(const char *alias, - const char *const *filenames, - uintptr_t length); - struct CanvasRenderingContext2D *canvas_native_context_create_with_wrapper(int64_t context, int64_t gl_context); @@ -677,10 +677,10 @@ void canvas_native_context_fill_text(struct CanvasRenderingContext2D *context, float y); void canvas_native_context_fill_text_width(struct CanvasRenderingContext2D *context, - const char *text, - float x, - float y, - float width); + const char *text, + float x, + float y, + float width); struct ImageData *canvas_native_context_get_image_data(struct CanvasRenderingContext2D *context, float sx, @@ -794,10 +794,10 @@ void canvas_native_context_stroke_text(struct CanvasRenderingContext2D *context, float y); void canvas_native_context_stroke_text_width(struct CanvasRenderingContext2D *context, - const char *text, - float x, - float y, - float width); + const char *text, + float x, + float y, + float width); void canvas_native_context_transform(struct CanvasRenderingContext2D *context, float a, @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate index ac5cc5acb..2931729c3 100644 Binary files a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate and b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate differ diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h index f799a4a91..b12b4557b 100644 --- a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h +++ b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist index 803c127dd..2552f82e9 100644 --- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist +++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist @@ -8,32 +8,32 @@ DebugSymbolsPath dSYMs LibraryIdentifier - ios-arm64 + ios-arm64_x86_64-simulator LibraryPath CanvasNative.framework SupportedArchitectures arm64 + x86_64 SupportedPlatform ios + SupportedPlatformVariant + simulator DebugSymbolsPath dSYMs LibraryIdentifier - ios-arm64_x86_64-simulator + ios-arm64 LibraryPath CanvasNative.framework SupportedArchitectures arm64 - x86_64 SupportedPlatform ios - SupportedPlatformVariant - simulator CFBundlePackageType diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative index 909b172d9..c89d31b36 100755 Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h index f799a4a91..b12b4557b 100644 --- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h +++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative index b7670f395..781f4f6c5 100644 Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative index 90dc866f2..192876b17 100755 Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h index f799a4a91..b12b4557b 100644 --- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h +++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h @@ -1461,18 +1461,48 @@ void canvas_native_webgl_buffer_data(uint32_t target, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i8(uint32_t target, + const int8_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_u16(uint32_t target, const uint16_t *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_i16(uint32_t target, + const int16_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_u32(uint32_t target, + const uint32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + +void canvas_native_webgl_buffer_data_i32(uint32_t target, + const int32_t *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_f32(uint32_t target, const float *src_data, uintptr_t size, uint32_t usage, struct WebGLState *state); +void canvas_native_webgl_buffer_data_f64(uint32_t target, + const double *src_data, + uintptr_t size, + uint32_t usage, + struct WebGLState *state); + void canvas_native_webgl_buffer_data_none(uint32_t target, intptr_t size, uint32_t usage, @@ -1484,6 +1514,48 @@ void canvas_native_webgl_buffer_sub_data(uint32_t target, uintptr_t size, struct WebGLState *state); +void canvas_native_webgl_buffer_sub_data_i8(uint32_t target, + intptr_t offset, + const int8_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i16(uint32_t target, + intptr_t offset, + const int16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u16(uint32_t target, + intptr_t offset, + const uint16_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_i32(uint32_t target, + intptr_t offset, + const int32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_u32(uint32_t target, + intptr_t offset, + const uint32_t *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f32(uint32_t target, + intptr_t offset, + const float *src_data, + uintptr_t size, + struct WebGLState *state); + +void canvas_native_webgl_buffer_sub_data_f64(uint32_t target, + intptr_t offset, + const double *src_data, + uintptr_t size, + struct WebGLState *state); + void canvas_native_webgl_buffer_sub_data_none(uint32_t target, intptr_t offset, struct WebGLState *state); diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources index a1e2d592d..8e4eb9030 100644 --- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources +++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources @@ -18,7 +18,7 @@ Headers/canvas_native.h - pRAw58hbawyHmNg47MpPInfGUXE= + OGCSEenyrzd3RyVAV445VyaSuSQ= Info.plist @@ -108,7 +108,7 @@ hash2 - +uJrcducrhwiNwtZ6wBUM2xpn2cfp1O2gq8/4NtuBVU= + 4ynTl1zPCBzVAd/oTD4NPvJlB6B79gIJMszZCwNazPg= Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative index 18fddfa1a..0e12c1e18 100644 Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ diff --git a/packages/canvas/src-native/canvas-native/canvas-2d/Cargo.toml b/packages/canvas/src-native/canvas-native/canvas-2d/Cargo.toml index 16f61ecf5..2cebe537c 100644 --- a/packages/canvas/src-native/canvas-native/canvas-2d/Cargo.toml +++ b/packages/canvas/src-native/canvas-native/canvas-2d/Cargo.toml @@ -19,7 +19,7 @@ csscolorparser = { git = "https://github.com/triniwiz/csscolorparser-rs.git", re #rgb = { version = "0.8.37", features = ["argb"] } log = "0.4.8" once_cell = "1.8.0" -skia-safe = { version = "0.69.0", features = ["gl", "svg", "textlayout"] } +skia-safe = { version = "0.70.0", features = ["gl", "svg", "textlayout"] } image = { version = "0.24.7", features = ["jpeg", "png", "gif"] } bytes = "1.5.0" env_logger = "0.10.1" \ No newline at end of file diff --git a/packages/canvas/src-native/canvas-native/canvas-android/Cargo.toml b/packages/canvas/src-native/canvas-native/canvas-android/Cargo.toml index 2b8462f01..a82df2dd4 100644 --- a/packages/canvas/src-native/canvas-native/canvas-android/Cargo.toml +++ b/packages/canvas/src-native/canvas-native/canvas-android/Cargo.toml @@ -22,5 +22,5 @@ ndk = { version = "0.7.0", features = ["bitmap"] } libloading = "0.8.1" log = "0.4.20" android_logger = "0.13.1" -skia-safe = { version = "0.69.0" } +skia-safe = { version = "0.70.0" } itertools = "0.12.0" \ No newline at end of file diff --git a/packages/canvas/src-native/canvas-native/canvas-android/build.rs b/packages/canvas/src-native/canvas-native/canvas-android/build.rs index 0a912dc30..8e6cae2a2 100644 --- a/packages/canvas/src-native/canvas-native/canvas-android/build.rs +++ b/packages/canvas/src-native/canvas-native/canvas-android/build.rs @@ -33,8 +33,23 @@ fn setup_x86_64_android_workaround() { "Unsupported OS. You must use either Linux, MacOS or Windows to build the crate." ), }; + + + let ndk_clang_version = if let Ok(mut android_version_txt) = File::open(&format!("{android_ndk_home}/toolchains/llvm/prebuilt/{build_os}-x86_64/AndroidVersion.txt")){ + let mut data = String::new(); + let _ = android_version_txt.read_to_string(&mut data); + let line = data.lines().take(1).next(); + line.unwrap_or("").to_string() + }else { + DEFAULT_CLANG_VERSION.to_string() + }; + let clang_version = - env::var("NDK_CLANG_VERSION").unwrap_or_else(|_| DEFAULT_CLANG_VERSION.to_owned()); + env::var("NDK_CLANG_VERSION") + .unwrap_or_else(|_| ndk_clang_version); + + + let linux_x86_64_lib_dir = format!( "toolchains/llvm/prebuilt/{build_os}-x86_64/lib64/clang/{clang_version}/lib/linux/" ); @@ -84,6 +99,7 @@ fn setup_aarch64_android_workaround() { let linux_aarch64_lib_dir = format!( "toolchains/llvm/prebuilt/{build_os}-x86_64/lib64/clang/{clang_version}/lib/linux/" ); + let linkpath = format!("{android_ndk_home}/{linux_aarch64_lib_dir}"); if Path::new(&linkpath).exists() { println!("cargo:rustc-link-search={android_ndk_home}/{linux_aarch64_lib_dir}"); diff --git a/packages/canvas/src-native/canvas-native/canvas-c/Cargo.toml b/packages/canvas/src-native/canvas-native/canvas-c/Cargo.toml index f4201c27a..fdf0dc0f2 100644 --- a/packages/canvas/src-native/canvas-native/canvas-c/Cargo.toml +++ b/packages/canvas/src-native/canvas-native/canvas-c/Cargo.toml @@ -18,7 +18,7 @@ canvas-webgl = { path = "../canvas-webgl", optional = true } parking_lot = "0.12.0" ureq = { version = "2.9.1", features = ["gzip"] } bytes = "1.5.0" -ada-url = { git = "https://github.com/triniwiz/ada-url-rust", rev = "bc35ae9" } +ada-url = "2.2.0" log = { version = "0.4.20"} [target.'cfg(target_os="ios")'.dependencies] @@ -29,5 +29,4 @@ display-link = "0.2.0" [target.'cfg(target_os="android")'.dependencies] ndk = { version = "0.7.0", features = ["bitmap"] } -once_cell = "1.14.0" -#ada-url = {git = "https://github.com/triniwiz/ada-url-rust" , rev = "bc35ae9"} \ No newline at end of file +once_cell = "1.14.0" \ No newline at end of file diff --git a/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs b/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs index 886bd7407..7c321317c 100644 --- a/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs +++ b/packages/canvas/src-native/canvas-native/canvas-c/src/lib.rs @@ -6131,6 +6131,25 @@ pub extern "C" fn canvas_native_webgl_buffer_data( ) } +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_data_i8( + target: u32, + src_data: *const i8, + size: usize, + usage: u32, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_data_i8( + target, + src_data, + usage, + state.get_inner_mut(), + ) +} + #[no_mangle] pub extern "C" fn canvas_native_webgl_buffer_data_u16( target: u32, @@ -6150,6 +6169,68 @@ pub extern "C" fn canvas_native_webgl_buffer_data_u16( ) } + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_data_i16( + target: u32, + src_data: *const i16, + size: usize, + usage: u32, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_data_i16( + target, + src_data, + usage, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_data_u32( + target: u32, + src_data: *const u32, + size: usize, + usage: u32, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_data_u32( + target, + src_data, + usage, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_data_i32( + target: u32, + src_data: *const i32, + size: usize, + usage: u32, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_data_i32( + target, + src_data, + usage, + state.get_inner_mut(), + ) +} + + + #[no_mangle] pub extern "C" fn canvas_native_webgl_buffer_data_f32( target: u32, @@ -6168,6 +6249,24 @@ pub extern "C" fn canvas_native_webgl_buffer_data_f32( ) } +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_data_f64( + target: u32, + src_data: *const f64, + size: usize, + usage: u32, + state: *mut WebGLState, +) { + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_data_f64( + target, + src_data, + usage, + state.get_inner_mut(), + ) +} + #[no_mangle] pub extern "C" fn canvas_native_webgl_buffer_data_none( target: u32, @@ -6203,6 +6302,148 @@ pub extern "C" fn canvas_native_webgl_buffer_sub_data( ) } + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_i8( + target: u32, + offset: isize, + src_data: *const i8, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_i8( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_i16( + target: u32, + offset: isize, + src_data: *const i16, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_i16( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_u16( + target: u32, + offset: isize, + src_data: *const u16, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_u16( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_i32( + target: u32, + offset: isize, + src_data: *const i32, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_i32( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_u32( + target: u32, + offset: isize, + src_data: *const u32, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_u32( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_f32( + target: u32, + offset: isize, + src_data: *const f32, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_f32( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + + +#[no_mangle] +pub extern "C" fn canvas_native_webgl_buffer_sub_data_f64( + target: u32, + offset: isize, + src_data: *const f64, + size: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src_data = unsafe { std::slice::from_raw_parts(src_data, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl::canvas_native_webgl_buffer_sub_data_f64( + target, + offset, + src_data, + state.get_inner_mut(), + ) +} + #[no_mangle] pub extern "C" fn canvas_native_webgl_buffer_sub_data_none( target: u32, diff --git a/packages/canvas/src-native/canvas-native/canvas-core/Cargo.toml b/packages/canvas/src-native/canvas-native/canvas-core/Cargo.toml index 665bf04bb..52275257e 100644 --- a/packages/canvas/src-native/canvas-native/canvas-core/Cargo.toml +++ b/packages/canvas/src-native/canvas-native/canvas-core/Cargo.toml @@ -12,7 +12,7 @@ gl-bindings = { path = "../gl-bindings" } raw-window-handle = "0.5.2" parking_lot = "0.12.0" image = { version = "0.24.7", features = ["jpeg", "png", "gif"] } -skia-safe = { version = "0.69.0", features = ["gl", "svg"], optional = true } +skia-safe = { version = "0.70.0", features = ["gl", "svg"], optional = true } once_cell = "1.14.0" log = "0.4.17" diff --git a/packages/canvas/src-native/canvas-native/canvas-core/src/image_asset.rs b/packages/canvas/src-native/canvas-native/canvas-core/src/image_asset.rs index c8f76a084..2bba83dde 100644 --- a/packages/canvas/src-native/canvas-native/canvas-core/src/image_asset.rs +++ b/packages/canvas/src-native/canvas-native/canvas-core/src/image_asset.rs @@ -86,7 +86,7 @@ enum ByteType { impl ImageAsset { pub fn copy(asset: &ImageAsset) -> Option { let asset = asset.0.write(); - let mut inner = ImageAssetInner { + let inner = ImageAssetInner { image: asset.image.clone(), luma_image: asset.luma_image.clone(), error: String::new(), diff --git a/packages/canvas/src-native/canvas-native/canvas-webgl/src/webgl.rs b/packages/canvas/src-native/canvas-native/canvas-webgl/src/webgl.rs index 3460cbe3c..30b0c26dd 100644 --- a/packages/canvas/src-native/canvas-native/canvas-webgl/src/webgl.rs +++ b/packages/canvas/src-native/canvas-native/canvas-webgl/src/webgl.rs @@ -165,6 +165,41 @@ pub fn canvas_native_webgl_buffer_data( } } +pub fn canvas_native_webgl_buffer_data_i8( + target: u32, + src_data: &[i8], + usage: u32, + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferData( + target, + src_data.len().try_into().unwrap(), + src_data.as_ptr() as *const c_void, + usage, + ); + } +} + +pub fn canvas_native_webgl_buffer_data_i16( + target: u32, + src_data: &[i16], + usage: u32, + state: &mut WebGLState, +) { + state.make_current(); + let len = src_data.len() * std::mem::size_of::(); + unsafe { + gl_bindings::BufferData( + target, + len.try_into().unwrap(), + src_data.as_ptr() as *const c_void, + usage, + ); + } +} + pub fn canvas_native_webgl_buffer_data_u16( target: u32, src_data: &[u16], @@ -201,6 +236,60 @@ pub fn canvas_native_webgl_buffer_data_f32( } } +pub fn canvas_native_webgl_buffer_data_f64( + target: u32, + src_data: &[f64], + usage: u32, + state: &mut WebGLState, +) { + state.make_current(); + let len = src_data.len() * std::mem::size_of::(); + unsafe { + gl_bindings::BufferData( + target, + len.try_into().unwrap(), + src_data.as_ptr() as *const c_void, + usage, + ); + } +} + +pub fn canvas_native_webgl_buffer_data_i32( + target: u32, + src_data: &[i32], + usage: u32, + state: &mut WebGLState, +) { + state.make_current(); + let len = src_data.len() * std::mem::size_of::(); + unsafe { + gl_bindings::BufferData( + target, + len.try_into().unwrap(), + src_data.as_ptr() as *const c_void, + usage, + ); + } +} + +pub fn canvas_native_webgl_buffer_data_u32( + target: u32, + src_data: &[u32], + usage: u32, + state: &mut WebGLState, +) { + state.make_current(); + let len = src_data.len() * std::mem::size_of::(); + unsafe { + gl_bindings::BufferData( + target, + len.try_into().unwrap(), + src_data.as_ptr() as *const c_void, + usage, + ); + } +} + pub fn canvas_native_webgl_buffer_data_none( target: u32, size: isize, @@ -230,6 +319,134 @@ pub fn canvas_native_webgl_buffer_sub_data( } } + +pub fn canvas_native_webgl_buffer_sub_data_i8( + target: u32, + offset: isize, + src_data: &[i8], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + src_data.len().try_into().unwrap(), + src_data.as_ptr() as *const c_void, + ); + } +} + +pub fn canvas_native_webgl_buffer_sub_data_i16( + target: u32, + offset: isize, + src_data: &[i16], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + + + +pub fn canvas_native_webgl_buffer_sub_data_u16( + target: u32, + offset: isize, + src_data: &[u16], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + + +pub fn canvas_native_webgl_buffer_sub_data_i32( + target: u32, + offset: isize, + src_data: &[i32], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + + +pub fn canvas_native_webgl_buffer_sub_data_u32( + target: u32, + offset: isize, + src_data: &[u32], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + + + + +pub fn canvas_native_webgl_buffer_sub_data_f32( + target: u32, + offset: isize, + src_data: &[f32], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + + +pub fn canvas_native_webgl_buffer_sub_data_f64( + target: u32, + offset: isize, + src_data: &[f64], + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::BufferSubData( + target, + offset.try_into().unwrap(), + >::try_into(src_data.len()).unwrap() * std::mem::size_of::() as isize, + src_data.as_ptr() as *const c_void, + ); + } +} + pub fn canvas_native_webgl_buffer_sub_data_none( target: u32, offset: isize, diff --git a/tools/scripts/android-build.sh b/tools/scripts/android-build.sh index 1cc3f7c2c..571452ca0 100644 --- a/tools/scripts/android-build.sh +++ b/tools/scripts/android-build.sh @@ -22,7 +22,7 @@ ANDROID_x86_64_OUTPUT="$ANDROID_x86_64_OUTPUT_DIR/debug/$OUTPUT_LIB_NAME" ANDROID_NDK_SYSROOT_LIB="$ANDROID_NDK/sysroot/usr/lib" LIBCPLUSPLUS_NAME="libc++_shared.so" #CARGO_FLAGS="-C target-cpu=native" -CARGO_FLAGS="" +CARGO_FLAGS="-Zlocation-detail=none -C target-cpu=native -C panic=abort" for arg in "$@" do if [[ "$arg" == "--help" ]] || [[ "$arg" == "-h" ]]