diff --git a/crates/canvas-c/src/webgl/gl.rs b/crates/canvas-c/src/webgl/gl.rs index 811e62927..97d2e74be 100644 --- a/crates/canvas-c/src/webgl/gl.rs +++ b/crates/canvas-c/src/webgl/gl.rs @@ -1279,6 +1279,20 @@ pub extern "C" fn canvas_native_webgl_result_get_bool_array( }))) } +#[no_mangle] +pub extern "C" fn canvas_native_webgl_result_into_bool_array( + result: *mut WebGLResult, +) -> Vec { + if result.is_null() { + return Vec::new(); + } + let result = unsafe { *Box::from_raw(result) }; + match result.0 { + canvas_webgl::prelude::WebGLResult::BooleanArray(value) => value, + _ => Vec::new(), + } +} + #[no_mangle] pub extern "C" fn canvas_native_webgl_result_get_u32(result: *const WebGLResult) -> u32 { let result = unsafe { &*result }; diff --git a/crates/canvas-c/src/webgl/gl2.rs b/crates/canvas-c/src/webgl/gl2.rs index 4f2e76a9b..95bc17e39 100644 --- a/crates/canvas-c/src/webgl/gl2.rs +++ b/crates/canvas-c/src/webgl/gl2.rs @@ -1,12 +1,12 @@ -use std::ffi::{CStr, CString}; -use std::os::raw::{c_char, c_ulong, c_void}; -use canvas_webgl::utils; -use canvas_webgl::utils::gl::bytes_per_pixel; use crate::buffers::U32Buffer; use crate::c2d::CanvasRenderingContext2D; use crate::image_asset::ImageAsset; -use crate::ImageData; use crate::webgl::gl::{WebGLActiveInfo, WebGLResult, WebGLState}; +use crate::ImageData; +use canvas_webgl::utils; +use canvas_webgl::utils::gl::bytes_per_pixel; +use std::ffi::{CStr, CString}; +use std::os::raw::{c_char, c_ulong, c_void}; pub struct WebGLSync(canvas_webgl::webgl2::GLSync); @@ -258,6 +258,69 @@ pub extern "C" fn canvas_native_webgl2_client_wait_sync( ) } +#[no_mangle] +pub extern "C" fn canvas_native_webgl2_compressed_tex_image3d_none( + target: u32, + level: i32, + internalformat: u32, + width: i32, + height: i32, + depth: i32, + border: i32, + image_size: i32, + offset: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let state = unsafe { &mut *state }; + canvas_webgl::webgl2::canvas_native_webgl2_compressed_tex_image3d_none( + target, + level, + internalformat, + width, + height, + depth, + border, + image_size, + offset, + state.get_inner_mut(), + ) +} + +#[no_mangle] +pub extern "C" fn canvas_native_webgl2_compressed_tex_image3d( + target: u32, + level: i32, + internalformat: u32, + width: i32, + height: i32, + depth: i32, + border: i32, + src: *const u8, + size: usize, + src_offset: usize, + src_length_override: usize, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let src = unsafe { std::slice::from_raw_parts(src, size) }; + let state = unsafe { &mut *state }; + canvas_webgl::webgl2::canvas_native_webgl2_compressed_tex_image3d( + target, + level, + internalformat, + width, + height, + depth, + border, + src, + src_offset, + src_length_override, + state.get_inner_mut(), + ) +} + + #[no_mangle] pub extern "C" fn canvas_native_webgl2_compressed_tex_sub_image3d_none( target: u32, @@ -270,7 +333,7 @@ pub extern "C" fn canvas_native_webgl2_compressed_tex_sub_image3d_none( depth: i32, format: u32, image_size: i32, - offset: i32, + offset: usize, state: *mut WebGLState, ) { assert!(!state.is_null()); @@ -426,6 +489,15 @@ pub extern "C" fn canvas_native_webgl2_delete_sampler_with_sampler( ) } +#[no_mangle] +pub extern "C" fn canvas_native_webgl2_sync_destroy( + sync: *const WebGLSync, +) { + if !sync.is_null() { + let _ = unsafe { Box::from_raw(sync as *mut WebGLSync) }; + } +} + #[no_mangle] pub extern "C" fn canvas_native_webgl2_delete_sync_with_sync( sync: *const WebGLSync, @@ -1104,7 +1176,6 @@ pub extern "C" fn canvas_native_webgl2_tex_image3d_canvas2d( let canvas = unsafe { &mut *canvas }; - // let (width, height) = (canvas.context.width(), canvas.context.height()); // let snapshot = canvas.context.as_data(); @@ -1138,6 +1209,57 @@ pub extern "C" fn canvas_native_webgl2_tex_image3d_canvas2d( ) } + +#[no_mangle] +pub extern "C" fn canvas_native_webgl2_tex_image3d_webgl( + target: u32, + level: i32, + internalformat: i32, + _width: i32, + _height: i32, + depth: i32, + border: i32, + format: u32, + type_: u32, + webgl: *mut WebGLState, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + assert!(!webgl.is_null()); + let state = unsafe { &mut *state }; + let webgl = unsafe { &mut *webgl }; + + + + let (width, height, bytes) = canvas_webgl::webgl::canvas_native_webgl_read_webgl_pixels( + &mut webgl.0, + &mut state.0, + internalformat, + format as i32, + ); + + // todo handle pre-multipied + // let premultiply = state.get_inner().get_premultiplied_alpha(); + + // let buf = source_ctx.read_pixels_with_alpha_premultiply(&snapshot, format as i32, premultiply); + + state.0.make_current(); + + canvas_webgl::webgl2::canvas_native_webgl2_tex_image3d( + target, + level, + internalformat, + width as i32, + height as i32, + depth, + border, + format, + type_, + bytes.as_slice(), + state.get_inner_mut(), + ) +} + #[no_mangle] pub extern "C" fn canvas_native_webgl2_tex_image3d( target: u32, @@ -1404,6 +1526,59 @@ pub extern "C" fn canvas_native_webgl2_tex_sub_image3d_canvas2d( ); } +#[no_mangle] +pub extern "C" fn canvas_native_webgl2_tex_sub_image3d_webgl( + target: u32, + level: i32, + xoffset: i32, + yoffset: i32, + zoffset: i32, + _width: i32, + _height: i32, + depth: i32, + format: u32, + type_: u32, + webgl: *mut WebGLState, + state: *mut WebGLState, +) { + assert!(!state.is_null()); + let state = unsafe { &mut *state }; + let webgl = unsafe { &mut *webgl }; + + let (width, height, bytes) = canvas_webgl::webgl::canvas_native_webgl_read_webgl_pixels( + &mut webgl.0, + &mut state.0, + gl_bindings::RGBA as _, + gl_bindings::RGBA as _, + ); + + + // canvas.make_current(); + // let (width, height) = (canvas.context.width(), canvas.context.height()); + // let data = canvas.context.as_data(); + + // let premultiply = state.get_inner().get_premultiplied_alpha(); + + // let buf = source_ctx.read_pixels_with_alpha_premultiply(&snapshot, format as i32, premultiply); + + state.0.make_current(); + + canvas_webgl::webgl2::canvas_native_webgl2_tex_sub_image3d( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type_, + bytes.as_slice(), + state.get_inner_mut(), + ); +} + #[no_mangle] pub extern "C" fn canvas_native_webgl2_tex_sub_image3d_offset( target: u32, @@ -1930,7 +2105,6 @@ pub extern "C" fn canvas_native_webgl2_tex_image2d_webgl( } - #[no_mangle] pub extern "C" fn canvas_native_webgl2_tex_image2d_canvas2d( target: i32, @@ -2004,8 +2178,8 @@ pub extern "C" fn canvas_native_webgl2_tex_image2d_canvas2d( let integers = match format as u32 { gl_bindings::RGBA_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rgba_integer(bytes.as_slice(), source_width as usize, source_height as usize)), gl_bindings::RGB_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rgb_integer(bytes.as_slice(), source_width as usize, source_height as usize)), - gl_bindings::RED_INTEGER =>Some(canvas_core::image_asset::ImageAsset::rgba_to_red_integer(bytes.as_slice(), source_width as usize, source_height as usize)), - gl_bindings::RG_INTEGER =>Some(canvas_core::image_asset::ImageAsset::rgba_to_rg_integer(bytes.as_slice(), source_width as usize, source_height as usize)), + gl_bindings::RED_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_red_integer(bytes.as_slice(), source_width as usize, source_height as usize)), + gl_bindings::RG_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rg_integer(bytes.as_slice(), source_width as usize, source_height as usize)), _ => None, }; @@ -2171,8 +2345,8 @@ pub extern "C" fn canvas_native_webgl2_tex_image2d_image_data( let integers = match format as u32 { gl_bindings::RGBA_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rgba_integer(bytes, source_width as usize, source_height as usize)), gl_bindings::RGB_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rgb_integer(bytes, source_width as usize, source_height as usize)), - gl_bindings::RED_INTEGER =>Some(canvas_core::image_asset::ImageAsset::rgba_to_red_integer(bytes, source_width as usize, source_height as usize)), - gl_bindings::RG_INTEGER =>Some(canvas_core::image_asset::ImageAsset::rgba_to_rg_integer(bytes, source_width as usize, source_height as usize)), + gl_bindings::RED_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_red_integer(bytes, source_width as usize, source_height as usize)), + gl_bindings::RG_INTEGER => Some(canvas_core::image_asset::ImageAsset::rgba_to_rg_integer(bytes, source_width as usize, source_height as usize)), _ => None, }; diff --git a/crates/canvas-webgl/src/webgl2.rs b/crates/canvas-webgl/src/webgl2.rs index a1cd8a193..7736a5fc7 100644 --- a/crates/canvas-webgl/src/webgl2.rs +++ b/crates/canvas-webgl/src/webgl2.rs @@ -166,6 +166,82 @@ pub fn canvas_native_webgl2_client_wait_sync( ret } + +pub fn canvas_native_webgl2_compressed_tex_image3d_none( + target: u32, + level: i32, + internalformat: u32, + width: i32, + height: i32, + depth: i32, + border: i32, + image_size: i32, + offset: usize, + state: &mut WebGLState, +) { + state.make_current(); + unsafe { + gl_bindings::CompressedTexImage3D( + target, + level, + internalformat, + width, + height, + depth, + border, + image_size, + offset as *const c_void, + ) + } +} + +pub fn canvas_native_webgl2_compressed_tex_image3d( + target: u32, + level: i32, + internalformat: u32, + width: i32, + height: i32, + depth: i32, + border: i32, + src: &[u8], + src_offset: usize, + src_length_override: usize, + state: &mut WebGLState, +) { + state.make_current(); + + let mut len = src.len(); + if src_offset > len { + return; + } + if src_length_override == 0 { + len = len - src_offset; + } else { + len = src_length_override; + } + + let mut buf = src; + if src_offset > 0 { + let ptr = unsafe { buf.as_ptr().offset(src_offset as isize) }; + buf = unsafe { std::slice::from_raw_parts(ptr, len) } + } + + unsafe { + gl_bindings::CompressedTexImage3D( + target, + level, + internalformat, + width, + height, + depth, + border, + len.try_into().unwrap(), + buf.as_ptr() as *const c_void, + ) + } +} + + pub fn canvas_native_webgl2_compressed_tex_sub_image3d_none( target: u32, level: i32, @@ -177,7 +253,7 @@ pub fn canvas_native_webgl2_compressed_tex_sub_image3d_none( depth: i32, format: u32, image_size: i32, - offset: i32, + offset: usize, state: &mut WebGLState, ) { state.make_current(); @@ -602,12 +678,12 @@ pub fn canvas_native_webgl2_get_buffer_sub_data( let len = dst_data.len(); - if dst_offset > len { + if dst_offset < len { // todo log error return; } - if length > len { + if length < len { // todo log error return; } @@ -804,7 +880,7 @@ pub fn canvas_native_webgl2_get_parameter(pname: u32, state: &mut WebGLState) -> if params[0] == 0 { return WebGLResult::None; } - return WebGLResult::I32(params[0]); + WebGLResult::I32(params[0]) } _ => canvas_native_webgl_get_parameter(pname, state), } @@ -963,9 +1039,9 @@ pub fn canvas_native_webgl2_get_uniform_block_index( ret } -pub fn canvas_native_webgl2_get_uniform_indices( +pub fn canvas_native_webgl2_get_uniform_indices>( program: u32, - uniform_names: &[&str], + uniform_names: &[T], state: &mut WebGLState, ) -> Vec { state.make_current(); @@ -973,7 +1049,7 @@ pub fn canvas_native_webgl2_get_uniform_indices( let mut count: Vec = vec![0; uniform_names.len()]; let mut buffer: Vec = Vec::with_capacity(uniform_names.len()); for name in uniform_names.iter() { - let name = CString::new(*name).unwrap(); + let name = CString::new(name.as_ref().to_string()).unwrap(); buffer.push(name); } @@ -1810,9 +1886,9 @@ pub fn canvas_native_webgl2_tex_sub_image3d_offset( ); } -pub fn canvas_native_webgl2_transform_feedback_varyings( +pub fn canvas_native_webgl2_transform_feedback_varyings>( program: u32, - varyings: &[String], + varyings: &[T], buffer_mode: u32, state: &mut WebGLState, ) { @@ -1820,8 +1896,8 @@ pub fn canvas_native_webgl2_transform_feedback_varyings( // todo improve performance ... no allocation :D let mut buf: Vec = Vec::with_capacity(varyings.len()); - for vary in varyings.into_iter() { - buf.push(CString::new(vary.as_str()).unwrap()) + for vary in varyings.iter() { + buf.push(CString::new(vary.as_ref().to_string()).unwrap()) } let buffer: Vec<*const c_char> = buf.iter().map(|f| f.as_ptr()).collect(); @@ -2325,9 +2401,7 @@ pub fn canvas_native_webgl2_tex_image2d_image_asset( type_: i32, src_data: &[u8], state: &WebGLState, -) { - -} +) {} /* GL_EXT */ diff --git a/napi/canvas-napi/canvas.js b/napi/canvas-napi/canvas.js new file mode 100644 index 000000000..705173347 --- /dev/null +++ b/napi/canvas-napi/canvas.js @@ -0,0 +1,553 @@ +const { CanvasRenderingContext2D, WebGLRenderingContext, WebGL2RenderingContext } = require('./index.js'); + +class NSCMTLView extends NSView { + static { + NativeClass(this); + } + _device; + _queue; + /** + * @param {WeakRef} canvas + */ + _canvas = null; + + get queue() { + return this._queue; + } + + get device() { + return this._device; + } + + initWithFrame(frameRect) { + super.initWithFrame(frameRect); + this.wantsLayer = true; + const layer = CAMetalLayer.layer(); + this._device = MTLCreateSystemDefaultDevice(); + this._queue = this._device.newCommandQueue(); + layer.device = this._device; + layer.presentsWithTransaction = false; + layer.framebufferOnly = false; + layer.pixelFormat = MTLPixelFormat.BGRA8Unorm; + + this.layer = layer; + return this; + } + + /** + * @return {CGSize} + */ + get drawableSize() { + return this.layer.drawableSize; + } + + /** + * @param {CGSize} value + */ + set drawableSize(value) { + this.layer.drawableSize = value; + } + + present() { + const owner = this._canvas.deref(); + if (owner) { + const ctx = owner.getContext('2d'); + ctx.flush(); + ctx.present(); + } + } + + static ObjCExposedMethods = { + present: { returns: interop.types.void, params: [] }, + }; +} + +class NSCGLView extends NSOpenGLView { + static { + NativeClass(this); + } + isDirty = false; + /** + * @param {WeakRef} canvas + */ + _canvas = null; + + initWithFrame(frame) { + super.initWithFrame(frame); + this.wantsLayer = true; + return this; + } + + prepareOpenGL() { + super.prepareOpenGL(); + } + + clearGLContext() { + super.clearGLContext(); + } +} + +// enum ContextType { +// None, +// Canvas, +// WebGL, +// WebGL2, +// WebGPU, +// } + +class NSCCanvas extends NSView { + static { + NativeClass(this); + } + + /** + * @param {WeakRef} canvas + */ + _canvas = null; + + /** + * @param {WeakRef} value + */ + set canvas(value) { + this._canvas = new WeakRef(value); + this.mtlView._canvas = this.glkView._canvas = this._canvas; + } + + get canvas() { + return this._canvas; + } + + /** + * @type {NSCMTLView} + */ + mtlView; + + /** + * @type {NSCGLView} + */ + glkView; + + /** + * @type {0 | 1 | 2 | 3 | 4} + */ + _fit = 2; + + set fit(value) { + if (typeof value === 'number') { + this._fit = value; + this.scaleSurface(); + } + } + + get fit() { + return this._fit; + } + + initWithFrame(frame) { + super.initWithFrame(frame); + this.wantsLayer = true; + + const scale = NSScreen.mainScreen.backingScaleFactor; + + const unscaledWidth = Math.floor(300 / scale); + const unscaledHeight = Math.floor(150 / scale); + + const newFrame = CGRectMake(0, 0, unscaledWidth, unscaledHeight); + this.mtlView = NSCMTLView.alloc().initWithFrame(newFrame); + this.glkView = NSCGLView.alloc().initWithFrame(newFrame); + this.mtlView.drawableSize = CGSizeMake(300, 150); + + this.initializeView(); + + return this; + } + + initializeView() { + this.glkView._canvas = this; + this.mtlView._canvas = this; + // handler = NSCTouchHandler(canvas: self) + this.layer.backgroundColor = NSColor.clearColor.CGColor; + this.glkView.isHidden = true; + this.mtlView.isHidden = true; + this.addSubview(this.glkView); + this.addSubview(this.mtlView); + this.scaleSurface(); + + this.isOpaque = false; + this.mtlView.isOpaque = false; + } + + /** + * @type {boolean} + */ + weblikeScale = true; + + scaleSurface() { + if (!this.weblikeScale == false) { + return; + } + if (this.surfaceWidth == 0 || this.surfaceHeight == 0) { + return; + } + + var density = NSScreen.mainScreen.backingScaleFactor; + + if (!autoScale) { + density = 1; + } + + let scaledInternalWidth = this.surfaceWidth / density; + let scaledInternalHeight = this.surfaceHeight / density; + + if (scaledInternalWidth == 0 || scaledInternalHeight == 0) { + return; + } + + const frame = this.frame; + + if (frame.size.width == 0 || Number.isNaN(frame.size.width) || frame.size.height == 0 || !Number.isNaN(frame.size.height)) { + return; + } + + let scaleX = frame.size.width / scaledInternalWidth; + let scaleY = frame.size.height / scaledInternalHeight; + + if (scaleX == 0 || Number.isNaN(scaleX) || scaleY == 0 || Number.isNaN(scaleY)) { + return; + } + + /** + * @type {CATransform3D} + */ + var transform = null; + + switch (this.fit) { + case 0: + // noop + transform = CATransform3DIdentity; + break; + case 1: + transform = CATransform3DMakeScale(scaleX, scaleY, 1); + case 2: + { + const dx = (frame.size.width - scaledInternalWidth) / 2; + const dy = (scaledInternalHeight * scaleX - scaledInternalHeight) / 2; + + transform = CATransform3DMakeScale(scaleX, scaleX, 1); + + transform = CATransform3DConcat(transform, CATransform3DMakeTranslation(dx, dy, 0)); + } + break; + case 3: + { + const dx = (scaledInternalWidth * scaleY - scaledInternalWidth) / 2; + const dy = (frame.size.height - scaledInternalHeight) / 2; + + transform = CATransform3DMakeScale(scaleY, scaleY, 1); + + transform = CATransform3DConcat(transform, CATransform3DMakeTranslation(dx, dy, 0)); + } + break; + case 4: + let scale = min(min(scaleX, scaleY), 1); + + transform = CATransform3DMakeScale(scale, scale, 1); + break; + } + + if (transform == null) { + return; + } + this.glkView.layer.transform = transform; + this.mtlView.layer.transform = transform; + } + + /** + * + * @param {number} width + * @param {number} height + */ + forceLayout(width, height) { + var unscaledWidth = width; + var unscaledHeight = height; + const scale = NSScreen.mainScreen.backingScaleFactor; + if (unscaledWidth <= 0) { + unscaledWidth = 1 / scale; + } else { + unscaledWidth = unscaledWidth / scale; + } + + if (unscaledHeight <= 0) { + unscaledHeight = 1 / scale; + } else { + unscaledHeight = unscaledHeight / scale; + } + + this.glkView.frame = CGRectMake(0, 0, unscaledWidth, unscaledHeight); + this.mtlView.frame = CGRectMake(0, 0, unscaledWidth, unscaledHeight); + this.mtlView.drawableSize = CGSizeMake(Math.floor(width), Math.floor(height)); + this.glkView.needsLayout = true; + this.mtlView.needsLayout = true; + this.glkView.layoutSubtreeIfNeeded(); + this.mtlView.layoutSubtreeIfNeeded(); + } + + _surfaceWidth = 300; + get surfaceWidth() { + return this._surfaceWidth; + } + + /** + * @param {number} value + */ + set surfaceWidth(value) { + if (typeof value === 'number') { + this._surfaceWidth = value; + this.forceLayout(value, this.surfaceHeight); + } + } + + _surfaceHeight = 150; + get surfaceHeight() { + return this._surfaceHeight; + } + + /** + * @param {number} value + */ + set surfaceHeight(value) { + if (typeof value === 'number') { + this._surfaceHeight = value; + this.forceLayout(this.surfaceWidth, value); + } + } +} + +class Style { + /** + * @type {Map} + */ + _values; + + /** + * @type {NSView} + */ + nativeElement; + + constructor() { + this._values = new Map(); + } + + get width() { + return this._values.get('width'); + } + set width(value) { + this._values.set('width', value); + } + + get height() { + return this._values.get('height'); + } + set height(value) { + this._values.set('height', value); + } +} + +class Canvas { + /** + * @type {NSCCanvas} + */ + _canvas = null; + constructor() { + this._canvas = NSCCanvas.alloc().initWithFrame(CGRectMake(0, 0, 500, 500)); + this._canvas.canvas = this; + this._style.nativeElement = this._canvas; + this._style.width = '100%'; + this._style.height = 'auto'; + } + + get lang() { + return NSLocale.currentLocale.languageCode; + } + + /** + * @param {string} value + */ + set lang(value) { + // todo + } + + /** + * @param {boolean} value + */ + _ignoreTouchEvents = false; + + /** + * @returns {boolean} + */ + get ignoreTouchEventsProperty() { + return this._ignoreTouchEvents; + } + + set ignoreTouchEventsProperty(value) { + this._ignoreTouchEvents = value; + } + + /** + * @type {boolean} + */ + static forceGL = false; + + get ios() { + return this._canvas; + } + + get nativeView() { + return this._canvas; + } + + get clientWidth() { + return 0; + } + + get clientHeight() { + return 0; + } + + set width(value) { + this._canvas.surfaceWidth = value; + } + + get width() { + return this._canvas.surfaceWidth; + } + + get height() { + return this._canvas.surfaceHeight; + } + + set height(value) { + this._canvas.surfaceHeight = value; + } + + /** + * @type {0 | 1 | 2 | 3 | 4} + */ + _contextType = 0; + + /** + * @type {CanvasRenderingContext2D} + */ + + _2dContext; + /** + * @type {WebGLRenderingContext} + */ + _webglContext; + + /** + * @type {WebGL2RenderingContext} + */ + _webgl2Context; + + // _gpuContext: GPUCanvasContext; + + addEventListener(type, listener, options) {} + + removeEventListener(type, listener, options) {} + + _style = new Style(); + get style() { + return this._style; + } + + get __native__context() { + switch (this._contextType) { + case 1: + return this._2dContext; + case 2: + return this._webglContext; + case 3: + return this._webgl2Context; + case 4: + return this._gpuContext; + default: + return null; + } + } + + get native() { + return this.__native__context; + } + + /** + * + * @param {string} type + * @param {number} encoderOptions + * @returns + */ + toDataURL(type, encoderOptions) { + if (this.width === 0 || this.height === 0) { + return 'data:,'; + } + if (!this.native) { + // todo + //return this._canvas.toDataURL(type, encoderOptions); + return 'data:,'; + } + if (this._contextType === 4) { + return this._gpuContext.toDataURL(type ?? 'image/png', encoderOptions ?? 0.92); + } + return this.native?.toDataURL?.(type ?? 'image/png', encoderOptions ?? 0.92); + } + + /** + * @param {("2d" | "webgl" | "experimental-webgl" | "webgl2" |"experimental-webgl2" | "webgpu")} contextType + */ + getContext(contextType, options) { + if (contextType === '2d') { + if (this._2dContext) { + return this._2dContext; + } + const scale = NSScreen.mainScreen.backingScaleFactor; + + if (Canvas.forceGL) { + const handle = interop.handleof(this._canvas.glkView); + this._2dContext = CanvasRenderingContext2D.withView(handle.toNumber(), this._canvas.surfaceWidth, this._canvas.surfaceHeight, scale, options?.alpha ?? true, 0, 90, 1); + this._canvas.glkView.isHidden = false; + this._contextType = 1; + } else { + const mtlViewHandle = interop.handleof(this._canvas.mtlView); + const deviceHandle = interop.handleof(this._canvas.mtlView.device); + const queueHandle = interop.handleof(this._canvas.mtlView.queue); + this._2dContext = CanvasRenderingContext2D.withMtlViewDeviceQueue(mtlViewHandle.toNumber(), deviceHandle.toNumber(), queueHandle.toNumber(), options?.alpha ?? true, scale, 1, 0, 90, 1); + this._canvas.mtlView.isHidden = false; + this._contextType = 1; + } + + return this._2dContext; + } else if (contextType === 'webgl' || contextType === 'experimental-webgl') { + if (this._webglContext) { + return this._webglContext; + } + + const handle = interop.handleof(this._canvas.glkView); + this._webglContext = WebGLRenderingContext.withView(handle.toNumber(), 2, true, false, false, false, 1, true, false, false, false, false, false); + this._canvas.glkView.isHidden = false; + this._contextType = 2; + } else if (contextType === 'webgl2' || contextType === 'experimental-webgl2') { + if (this._webgl2Context) { + return this._webgl2Context; + } + + const handle = interop.handleof(this._canvas.glkView); + this._webgl2Context = WebGL2RenderingContext.withView(handle.toNumber(), 2, true, false, false, false, 1, true, false, false, false, false, false); + this._canvas.glkView.isHidden = false; + this._contextType = 2; + } + + return null; + } +} + +module.exports.Canvas = Canvas; diff --git a/napi/canvas-napi/deno.ts b/napi/canvas-napi/deno.ts index 6ccbadbe8..8ed45442b 100644 --- a/napi/canvas-napi/deno.ts +++ b/napi/canvas-napi/deno.ts @@ -7,8 +7,14 @@ const require = createRequire(import.meta.url); import '@nativescript/macos-node-api'; const { CanvasRenderingContext2D, ImageAsset, Path2D } = require('./canvas-napi.darwin-arm64.node'); +const { requestAnimationFrame } = require('./utils'); + objc.import('OpenGL'); +requestAnimationFrame(function (ts) { + console.log('ts', ts); +}); + export class ApplicationDelegate extends NSObject { static ObjCProtocols = [NSApplicationDelegate, NSWindowDelegate]; diff --git a/napi/canvas-napi/index.d.ts b/napi/canvas-napi/index.d.ts index 12eb3a000..3377513e1 100644 --- a/napi/canvas-napi/index.d.ts +++ b/napi/canvas-napi/index.d.ts @@ -53,8 +53,6 @@ export declare class WebGLRenderingContext { render(): void; get drawingBufferWidth(): number; get drawingBufferHeight(): number; - static withView(view: number, version: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean): WebGLRenderingContext; - static offscreen(width: number, height: number, version: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean, isCanvas: boolean): WebGLRenderingContext; activeTexture(texture: number): void; attachShader(program: WebGLProgram, shader: WebGLShader): void; bindAttribLocation(program: WebGLProgram, index: number, name: string): void; @@ -119,7 +117,6 @@ export declare class WebGLRenderingContext { getError(): number; getExtension(name: string): unknown; getFramebufferAttachmentParameter(target: number, attachment: number, pname: number): unknown; - getParameter(pname: number): unknown; getProgramInfoLog(program: WebGLProgram): string; getProgramParameter(program: WebGLProgram, pname: number): unknown; getRenderbufferParameter(target: number, pname: number): number; @@ -192,6 +189,9 @@ export declare class WebGLRenderingContext { vertexAttribPointer(index: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void; viewport(x: number, y: number, width: number, height: number): void; toDataURL(format?: string | undefined | null, encoderOptions?: number | undefined | null): string; + static withView(view: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean): WebGLRenderingContext; + static offscreen(width: number, height: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean, isCanvas: boolean): WebGLRenderingContext; + getParameter(pname: number): unknown; get DEPTH_BUFFER_BIT(): number; get STENCIL_BUFFER_BIT(): number; get COLOR_BUFFER_BIT(): number; @@ -666,5 +666,798 @@ export declare class TextDecoder { get encoding(): string; decode(data: Uint8Array): string; } +export declare class WebGLQuery {} +export declare class WebGLSampler {} +export declare class WebGLTransformFeedback {} +export declare class WebGLVertexArrayObject {} +export declare class WebGLSync {} export type web_g_l_2_rendering_context = WebGL2RenderingContext; -export declare class WebGL2RenderingContext {} +export declare class WebGL2RenderingContext { + render(): void; + get drawingBufferWidth(): number; + get drawingBufferHeight(): number; + activeTexture(texture: number): void; + attachShader(program: WebGLProgram, shader: WebGLShader): void; + bindAttribLocation(program: WebGLProgram, index: number, name: string): void; + bindBuffer(target: number, buffer: WebGLBuffer): void; + bindFramebuffer(target: number, framebuffer: WebGLFramebuffer): void; + bindRenderbuffer(target: number, renderbuffer: WebGLRenderbuffer): void; + bindTexture(target: number, texture: WebGLTexture): void; + blendColor(red: number, green: number, blue: number, alpha: number): void; + blendEquationSeparate(modeRGB: number, modeAlpha: number): void; + blendEquation(mode: number): void; + blendFuncSeparate(srcRGB?: number | undefined | null, dstRGB?: number | undefined | null, srcAlpha?: number | undefined | null, dstAlpha?: number | undefined | null): void; + blendFunc(sfactor?: number | undefined | null, dfactor?: number | undefined | null): void; + bufferData(target: number, sizeOrSrcData?: number | Buffer | undefined | null, usage?: number | undefined | null): void; + bufferSubData(target: number, offset: number, srcData: Uint8Array): void; + checkFramebufferStatus(target: number): number; + clearColor(red: number, green: number, blue: number, alpha: number): void; + clearDepth(depth: number): void; + clearStencil(stencil: number): void; + clear(mask: number): void; + colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void; + commit(): void; + compileShader(shader: WebGLShader): void; + compressedTexImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, pixels: Uint8Array): void; + compressedTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, pixels: Uint8Array): void; + copyTexImage2D(target: number, level: number, internalformat: number, x: number, y: number, width: number, height: number, border: number): void; + copyTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, x: number, y: number, width: number, height: number): void; + createBuffer(): WebGLBuffer; + createFramebuffer(): WebGLFramebuffer; + createProgram(): WebGLProgram; + createRenderbuffer(): WebGLRenderbuffer; + createShader(type: number): WebGLShader; + createTexture(): WebGLTexture; + cullFace(mode: number): void; + deleteBuffer(buffer: WebGLBuffer): void; + deleteFramebuffer(frameBuffer: WebGLFramebuffer): void; + deleteProgram(program: WebGLProgram): void; + deleteRenderbuffer(renderBuffer: WebGLRenderbuffer): void; + deleteShader(shader: WebGLRenderbuffer): void; + deleteTexture(texture: WebGLTexture): void; + depthFunc(func: number): void; + depthMask(flag: boolean): void; + depthRange(zNear: number, zFar: number): void; + detachShader(program: WebGLProgram, shader: WebGLShader): void; + disableVertexAttribArray(index: number): void; + disable(cap: number): void; + drawArrays(mode: number, first: number, count: number): void; + drawElements(mode: number, count: number, type: number, offset: number): void; + enableVertexAttribArray(index: number): void; + enable(cap: number): void; + finish(): void; + flush(): void; + framebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: WebGLRenderbuffer): void; + framebufferTexture2D(target: number, attachment: number, textarget: number, texture: WebGLTexture, level: number): void; + frontFace(mode: number): void; + generateMipmap(target: number): void; + getActiveAttrib(program: WebGLProgram, index: number): WebGLActiveInfo; + getActiveUniform(program: WebGLProgram, index: number): WebGLActiveInfo; + getAttachedShaders(program: WebGLProgram): Array; + getAttribLocation(program: WebGLProgram, name: string): number; + getBufferParameter(target: number, pname: number): number; + getContextAttributes(): ContextAttributes; + getError(): number; + getExtension(name: string): unknown; + getFramebufferAttachmentParameter(target: number, attachment: number, pname: number): unknown; + getProgramInfoLog(program: WebGLProgram): string; + getProgramParameter(program: WebGLProgram, pname: number): unknown; + getRenderbufferParameter(target: number, pname: number): number; + getShaderInfoLog(shader: WebGLShader): string; + getShaderParameter(shader: WebGLShader, pname: number): unknown; + getShaderPrecisionFormat(shaderType: number, precisionType: number): WebGLShaderPrecisionFormat; + getShaderSource(shader: WebGLShader): string; + getSupportedExtensions(): Array; + getTexParameter(target: number, pname: number): number; + getUniformLocation(program: WebGLProgram, name: string): unknown; + getUniform(program: WebGLProgram, location: WebGLUniformLocation): unknown; + getVertexAttribOffset(index: number, pname: number): number; + getVertexAttrib(index: number, pname: number): unknown; + hint(target: number, mode: number): void; + isBuffer(buffer: WebGLBuffer): boolean; + isContextLost(): boolean; + isEnabled(cap: number): boolean; + isFramebuffer(framebuffer?: WebGLFramebuffer | undefined | null): boolean; + isProgram(program: WebGLProgram): boolean; + isRenderbuffer(renderbuffer: WebGLRenderbuffer): boolean; + isShader(shader: WebGLShader): boolean; + isTexture(texture: WebGLTexture): boolean; + lineWidth(width: number): void; + linkProgram(program: WebGLProgram): void; + pixelStorei(pname: number, param: boolean | number): void; + polygonOffset(factor: number, units: number): void; + readPixels(x: number, y: number, width: number, height: number, format: number, type: number, pixels: ArrayBuffer | ArrayBufferView): void; + renderbufferStorage(target: number, internalFormat: number, width: number, height: number): void; + sampleCoverage(value: number, invert: boolean): void; + scissor(x: number, y: number, width: number, height: number): void; + shaderSource(shader: WebGLShader, source: string): void; + stencilFuncSeparate(face: number, func: number, ref: number, mask: number): void; + stencilFunc(func: number, ref: number, mask: number): void; + stencilMaskSeparate(face: number, mask: number): void; + stencilMask(mask: number): void; + stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void; + stencilOp(fail: number, zfail: number, zpass: number): void; + texImage2D(target: number, level: number, internalformat: number, widthOrFormat: number, heightOrType: number, borderOrPixels: number | CanvasRenderingContext2D | WebGLRenderingContext | ImageAsset, format?: number | undefined | null, type?: number | undefined | null, pixels?: Buffer | number | undefined | null, offset?: number | undefined | null): void; + texParameterf(target: number, pname: number, param: number): void; + texParameteri(target: number, pname: number, param: number): void; + uniform1f(location: WebGLUniformLocation, v0: number): void; + uniform1iv(location: WebGLUniformLocation, value: Array | Int32Array): void; + uniform1fv(location: WebGLUniformLocation, value: Array | Float32Array): void; + uniform1i(location: WebGLUniformLocation, v0: number): void; + uniform2f(location: WebGLUniformLocation, v0: number, v1: number): void; + uniform2iv(location: WebGLUniformLocation, value: Array | Int32Array): void; + uniform2fv(location: WebGLUniformLocation, value: Array | Float32Array): void; + uniform2i(location: WebGLUniformLocation, v0: number, v1: number): void; + uniform3f(location: WebGLUniformLocation, v0: number, v1: number, v2: number): void; + uniform3iv(location: WebGLUniformLocation, value: Array | Int32Array): void; + uniform3fv(location: WebGLUniformLocation, value: Array | Float32Array): void; + uniform3i(location: WebGLUniformLocation, v0: number, v1: number, v2: number): void; + uniform4f(location: WebGLUniformLocation, v0: number, v1: number, v2: number, v3: number): void; + uniform4iv(location: WebGLUniformLocation, value: Array | Int32Array): void; + uniform4fv(location: WebGLUniformLocation, value: Array | Float32Array): void; + uniform4i(location: WebGLUniformLocation, v0: number, v1: number, v2: number, v3: number): void; + uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: Array | Float32Array): void; + uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: Array | Float32Array): void; + uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: Array | Float32Array): void; + useProgram(program?: WebGLProgram | undefined | null): void; + validateProgram(program: WebGLProgram): void; + vertexAttrib1f(index: number, v0: number): void; + vertexAttrib1fv(index: number, value: Array | Float32Array): void; + vertexAttrib2f(index: number, v0: number, v1: number): void; + vertexAttrib2fv(index: number, value: Array | Float32Array): void; + vertexAttrib3f(index: number, v0: number, v1: number, v2: number): void; + vertexAttrib3fv(index: number, value: Array | Float32Array): void; + vertexAttrib4f(index: number, v0: number, v1: number, v2: number, v3: number): void; + vertexAttrib4fv(index: number, value: Array | Float32Array): void; + vertexAttribPointer(index: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void; + viewport(x: number, y: number, width: number, height: number): void; + toDataURL(format?: string | undefined | null, encoderOptions?: number | undefined | null): string; + static withView(view: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean): WebGL2RenderingContext; + static offscreen(width: number, height: number, alpha: boolean, antialias: boolean, depth: boolean, failIfMajorPerformanceCaveat: boolean, powerPreference: number, premultipliedAlpha: boolean, preserveDrawingBuffer: boolean, stencil: boolean, desynchronized: boolean, xrCompatible: boolean, isCanvas: boolean): WebGL2RenderingContext; + beginQuery(target: number, query: WebGLQuery): void; + beginTransformFeedback(primitiveMode: number): void; + bindBufferBase(target: number, index: number, buffer: WebGLBuffer): void; + bindBufferRange(target: number, index: number, buffer: WebGLBuffer, offset: number, size: number): void; + bindSampler(unit: number, sampler: WebGLSampler): void; + bindTransformFeedback(target: number, transformFeedback: WebGLTransformFeedback): void; + bindVertexArray(vertexArray: WebGLVertexArrayObject): void; + blitFramebuffer(srcX0: number, srcY0: number, srcX1: number, srcY1: number, dstX0: number, dstY0: number, dstX1: number, dstY1: number, mask: number, filter: number): void; + clearBufferfi(buffer: WebGLBuffer, drawbuffer: number, depth: number, stencil: number): void; + clearBufferfv(buffer: WebGLBuffer, drawbuffer: number, values: Array | Float32Array): void; + clearBufferiv(buffer: WebGLBuffer, drawbuffer: number, values: Array | Int32Array): void; + clearBufferuiv(buffer: WebGLBuffer, drawbuffer: number, values: Array | Uint32Array): void; + clientWaitSync(sync: WebGLSync, flags: number, timeout: number): number; + compressedTexImage3D(target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, imageSizeOrSrcData: number | Buffer, srcOffset?: number | undefined | null, srcLengthOverride?: number | undefined | null): void; + compressedTexSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, imageSizeOrSrcData: number | Buffer, srcOffset?: number | undefined | null, srcLengthOverride?: number | undefined | null): void; + copyBufferSubData(readTarget: number, writeTarget: number, readOffset: number, writeOffset: number, size: number): void; + copyTexSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, x: number, y: number, width: number, height: number): void; + createQuery(): WebGLQuery; + createSampler(): WebGLSampler; + createTransformFeedback(): WebGLTransformFeedback; + createVertexArray(): WebGLVertexArrayObject; + deleteQuery(query: WebGLQuery): void; + deleteSampler(sampler: WebGLSampler): void; + deleteSync(sync: WebGLSync): void; + deleteTransformFeedback(transformFeedback: WebGLTransformFeedback): void; + deleteVertexArray(vertexArray: WebGLVertexArrayObject): void; + drawArraysInstanced(mode: number, first: number, count: number, instanceCount: number): void; + drawBuffers(buffers: Uint32Array): void; + drawElementsInstanced(mode: number, count: number, type: number, offset: number, instanceCount: number): void; + drawRangeElements(mode: number, start: number, end: number, count: number, type: number, offset: number): void; + endQuery(target: number): void; + endTransformFeedback(): void; + fenceSync(condition: number, flags: number): WebGLSync; + framebufferTextureLayer(target: number, attachment: number, texture: WebGLTexture, level: number, layer: number): void; + getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: number): string; + getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: number, pname: number): unknown; + getActiveUniforms(program: WebGLProgram, uniformIndices: Uint32Array, pname: number): unknown; + getBufferSubData(target: number, srcByteOffset: number, dstData: Buffer, dstOffset?: number | undefined | null, length?: number | undefined | null): void; + getFragDataLocation(program: WebGLProgram, name: string): number | null; + getIndexedParameter(target: number, index: number): unknown; + getInternalformatParameter(target: number, internalformat: number, pname: number): unknown; + getQueryParameter(query: WebGLQuery, pname: number): unknown; + getParameter(pname: number): unknown; + getQuery(target: number, pname: number): unknown; + getSamplerParameter(sampler: WebGLSampler, pname: number): unknown; + getSyncParameter(sync: WebGLSync, pname: number): unknown; + getTransformFeedbackVarying(program: WebGLProgram, index: number): WebGLActiveInfo | null; + getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): number; + getUniformIndices(program: WebGLProgram, uniformNames: Array): Array; + invalidateFramebuffer(target: number, attachments: Uint32Array): void; + invalidateSubFramebuffer(target: number, attachments: Uint32Array, x: number, y: number, width: number, height: number): void; + isQuery(query: WebGLQuery): boolean; + isSampler(sampler: WebGLSampler): boolean; + isSync(sync: WebGLSync): boolean; + isTransformFeedback(transformFeedback: WebGLTransformFeedback): boolean; + isVertexArray(vertexArray: WebGLVertexArrayObject): boolean; + pauseTransformFeedback(): void; + readBuffer(src: number): void; + renderbufferStorageMultisample(target: number, samples: number, internalFormat: number, width: number, height: number): void; + resumeTransformFeedback(): void; + samplerParameterf(sampler: WebGLSampler, pname: number, param: number): void; + samplerParameteri(sampler: WebGLSampler, pname: number, param: number): void; + texImage3D(target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, format: number, type: number, offsetOrSourceOrSrcData: number | Buffer | CanvasRenderingContext2D | WebGLRenderingContext | WebGL2RenderingContext, srcOffset?: number | undefined | null): void; + texStorage2D(target: number, levels: number, internalformat: number, width: number, height: number): void; + texStorage3D(target: number, levels: number, internalformat: number, width: number, height: number, depth: number): void; + texSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, type: number, srcData: number | Buffer | CanvasRenderingContext2D | WebGLRenderingContext | WebGL2RenderingContext, srcOffset?: number | undefined | null): void; + transformFeedbackVaryings(program: WebGLProgram, varyings: Array, bufferMode: number): void; + uniform1ui(location: WebGLUniformLocation, v0: number): void; + uniform1uiv(location: WebGLUniformLocation, data: Uint32Array | Uint32Array): void; + uniform2ui(location: WebGLUniformLocation, v0: number, v1: number): void; + uniform2uiv(location: WebGLUniformLocation, data: Uint32Array | Uint32Array): void; + uniform3ui(location: WebGLUniformLocation, v0: number, v1: number, v2: number): void; + uniform3uiv(location: WebGLUniformLocation, data: Uint32Array | Uint32Array): void; + uniform4ui(location: WebGLUniformLocation, v0: number, v1: number, v2: number, v3: number): void; + uniform4uiv(location: WebGLUniformLocation, data: Uint32Array | Uint32Array): void; + uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: number, uniformBlockBinding: number): void; + uniformMatrix2x3fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + uniformMatrix2x4fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + uniformMatrix3x2fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + uniformMatrix3x4fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + uniformMatrix4x2fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + uniformMatrix4x3fv(location: WebGLUniformLocation, transpose: boolean, data: Float32Array): void; + vertexAttribDivisor(index: number, divisor: number): void; + vertexAttribI4i(index: number, v0: number, v1: number, v2: number, v3: number): void; + vertexAttribI4ui(index: number, v0: number, v1: number, v2: number, v3: number): void; + vertexAttribI4iv(index: number, value: Int32Array | Int32Array): void; + vertexAttribI4uiv(index: number, value: Uint32Array | Uint32Array): void; + get DEPTH_BUFFER_BIT(): number; + get STENCIL_BUFFER_BIT(): number; + get COLOR_BUFFER_BIT(): number; + get POINTS(): number; + get LINES(): number; + get LINE_LOOP(): number; + get LINE_STRIP(): number; + get TRIANGLES(): number; + get TRIANGLE_STRIP(): number; + get TRIANGLE_FAN(): number; + get ZERO(): number; + get ONE(): number; + get SRC_COLOR(): number; + get ONE_MINUS_SRC_COLOR(): number; + get SRC_ALPHA(): number; + get ONE_MINUS_SRC_ALPHA(): number; + get DST_ALPHA(): number; + get ONE_MINUS_DST_ALPHA(): number; + get DST_COLOR(): number; + get ONE_MINUS_DST_COLOR(): number; + get SRC_ALPHA_SATURATE(): number; + get CONSTANT_COLOR(): number; + get ONE_MINUS_CONSTANT_COLOR(): number; + get CONSTANT_ALPHA(): number; + get ONE_MINUS_CONSTANT_ALPHA(): number; + get FUNC_ADD(): number; + get FUNC_SUBTRACT(): number; + get FUNC_REVERSE_SUBTRACT(): number; + get BLEND_EQUATION(): number; + get BLEND_EQUATION_RGB(): number; + get BLEND_EQUATION_ALPHA(): number; + get BLEND_DST_RGB(): number; + get BLEND_SRC_RGB(): number; + get BLEND_DST_ALPHA(): number; + get BLEND_SRC_ALPHA(): number; + get BLEND_COLOR(): number; + get ARRAY_BUFFER_BINDING(): number; + get ELEMENT_ARRAY_BUFFER_BINDING(): number; + get LINE_WIDTH(): number; + get ALIASED_POINT_SIZE_RANGE(): number; + get ALIASED_LINE_WIDTH_RANGE(): number; + get CULL_FACE_MODE(): number; + get FRONT_FACE(): number; + get DEPTH_RANGE(): number; + get DEPTH_WRITEMASK(): number; + get DEPTH_CLEAR_VALUE(): number; + get DEPTH_FUNC(): number; + get STENCIL_CLEAR_VALUE(): number; + get STENCIL_FUNC(): number; + get STENCIL_FAIL(): number; + get STENCIL_PASS_DEPTH_FAIL(): number; + get STENCIL_PASS_DEPTH_PASS(): number; + get STENCIL_REF(): number; + get STENCIL_VALUE_MASK(): number; + get STENCIL_WRITEMASK(): number; + get STENCIL_BACK_FUNC(): number; + get STENCIL_BACK_FAIL(): number; + get STENCIL_BACK_PASS_DEPTH_FAIL(): number; + get STENCIL_BACK_PASS_DEPTH_PASS(): number; + get STENCIL_BACK_REF(): number; + get STENCIL_BACK_VALUE_MASK(): number; + get STENCIL_BACK_WRITEMASK(): number; + get VIEWPORT(): number; + get SCISSOR_BOX(): number; + get COLOR_CLEAR_VALUE(): number; + get COLOR_WRITEMASK(): number; + get UNPACK_ALIGNMENT(): number; + get PACK_ALIGNMENT(): number; + get MAX_TEXTURE_SIZE(): number; + get MAX_VIEWPORT_DIMS(): number; + get SUBPIXEL_BITS(): number; + get RED_BITS(): number; + get GREEN_BITS(): number; + get BLUE_BITS(): number; + get ALPHA_BITS(): number; + get DEPTH_BITS(): number; + get STENCIL_BITS(): number; + get POLYGON_OFFSET_UNITS(): number; + get POLYGON_OFFSET_FACTOR(): number; + get TEXTURE_BINDING_2D(): number; + get SAMPLE_BUFFERS(): number; + get SAMPLES(): number; + get SAMPLE_COVERAGE_VALUE(): number; + get SAMPLE_COVERAGE_INVERT(): number; + get COMPRESSED_TEXTURE_FORMATS(): number; + get VENDOR(): number; + get RENDERER(): number; + get VERSION(): number; + get IMPLEMENTATION_COLOR_READ_TYPE(): number; + get IMPLEMENTATION_COLOR_READ_FORMAT(): number; + get BROWSER_DEFAULT_WEBGL(): number; + get STATIC_DRAW(): number; + get STREAM_DRAW(): number; + get DYNAMIC_DRAW(): number; + get ARRAY_BUFFER(): number; + get ELEMENT_ARRAY_BUFFER(): number; + get BUFFER_SIZE(): number; + get BUFFER_USAGE(): number; + get CURRENT_VERTEX_ATTRIB(): number; + get VERTEX_ATTRIB_ARRAY_ENABLED(): number; + get VERTEX_ATTRIB_ARRAY_SIZE(): number; + get VERTEX_ATTRIB_ARRAY_STRIDE(): number; + get VERTEX_ATTRIB_ARRAY_TYPE(): number; + get VERTEX_ATTRIB_ARRAY_NORMALIZED(): number; + get VERTEX_ATTRIB_ARRAY_POINTER(): number; + get VERTEX_ATTRIB_ARRAY_BUFFER_BINDING(): number; + get CULL_FACE(): number; + get FRONT(): number; + get BACK(): number; + get FRONT_AND_BACK(): number; + get BLEND(): number; + get DEPTH_TEST(): number; + get DITHER(): number; + get POLYGON_OFFSET_FILL(): number; + get SAMPLE_ALPHA_TO_COVERAGE(): number; + get SAMPLE_COVERAGE(): number; + get SCISSOR_TEST(): number; + get STENCIL_TEST(): number; + get NO_ERROR(): number; + get INVALID_ENUM(): number; + get INVALID_VALUE(): number; + get INVALID_OPERATION(): number; + get OUT_OF_MEMORY(): number; + get CONTEXT_LOST_WEBGL(): number; + get CW(): number; + get CCW(): number; + get DONT_CARE(): number; + get FASTEST(): number; + get NICEST(): number; + get GENERATE_MIPMAP_HINT(): number; + get BYTE(): number; + get UNSIGNED_BYTE(): number; + get SHORT(): number; + get UNSIGNED_SHORT(): number; + get INT(): number; + get UNSIGNED_INT(): number; + get FLOAT(): number; + get DEPTH_COMPONENT(): number; + get ALPHA(): number; + get RGB(): number; + get RGBA(): number; + get LUMINANCE(): number; + get LUMINANCE_ALPHA(): number; + get UNSIGNED_SHORT_4_4_4_4(): number; + get UNSIGNED_SHORT_5_5_5_1(): number; + get UNSIGNED_SHORT_5_6_5(): number; + get FRAGMENT_SHADER(): number; + get VERTEX_SHADER(): number; + get COMPILE_STATUS(): number; + get DELETE_STATUS(): number; + get LINK_STATUS(): number; + get VALIDATE_STATUS(): number; + get ATTACHED_SHADERS(): number; + get ACTIVE_ATTRIBUTES(): number; + get ACTIVE_UNIFORMS(): number; + get MAX_VERTEX_ATTRIBS(): number; + get MAX_VERTEX_UNIFORM_VECTORS(): number; + get MAX_VARYING_VECTORS(): number; + get MAX_COMBINED_TEXTURE_IMAGE_UNITS(): number; + get MAX_VERTEX_TEXTURE_IMAGE_UNITS(): number; + get MAX_TEXTURE_IMAGE_UNITS(): number; + get MAX_FRAGMENT_UNIFORM_VECTORS(): number; + get SHADER_TYPE(): number; + get SHADING_LANGUAGE_VERSION(): number; + get CURRENT_PROGRAM(): number; + get NEVER(): number; + get LESS(): number; + get EQUAL(): number; + get LEQUAL(): number; + get GREATER(): number; + get NOTEQUAL(): number; + get GEQUAL(): number; + get ALWAYS(): number; + get KEEP(): number; + get REPLACE(): number; + get INCR(): number; + get DECR(): number; + get INVERT(): number; + get INCR_WRAP(): number; + get DECR_WRAP(): number; + get NEAREST(): number; + get LINEAR(): number; + get NEAREST_MIPMAP_NEAREST(): number; + get LINEAR_MIPMAP_NEAREST(): number; + get NEAREST_MIPMAP_LINEAR(): number; + get LINEAR_MIPMAP_LINEAR(): number; + get TEXTURE_MAG_FILTER(): number; + get TEXTURE_MIN_FILTER(): number; + get TEXTURE_WRAP_S(): number; + get TEXTURE_WRAP_T(): number; + get TEXTURE_2D(): number; + get TEXTURE(): number; + get TEXTURE_CUBE_MAP(): number; + get TEXTURE_BINDING_CUBE_MAP(): number; + get TEXTURE_CUBE_MAP_POSITIVE_X(): number; + get TEXTURE_CUBE_MAP_NEGATIVE_X(): number; + get TEXTURE_CUBE_MAP_POSITIVE_Y(): number; + get TEXTURE_CUBE_MAP_NEGATIVE_Y(): number; + get TEXTURE_CUBE_MAP_POSITIVE_Z(): number; + get TEXTURE_CUBE_MAP_NEGATIVE_Z(): number; + get MAX_CUBE_MAP_TEXTURE_SIZE(): number; + get TEXTURE0(): number; + get TEXTURE1(): number; + get TEXTURE2(): number; + get TEXTURE3(): number; + get TEXTURE4(): number; + get TEXTURE5(): number; + get TEXTURE6(): number; + get TEXTURE7(): number; + get TEXTURE8(): number; + get TEXTURE9(): number; + get TEXTURE10(): number; + get TEXTURE11(): number; + get TEXTURE12(): number; + get TEXTURE13(): number; + get TEXTURE14(): number; + get TEXTURE15(): number; + get TEXTURE16(): number; + get TEXTURE17(): number; + get TEXTURE18(): number; + get TEXTURE19(): number; + get TEXTURE20(): number; + get TEXTURE21(): number; + get TEXTURE22(): number; + get TEXTURE23(): number; + get TEXTURE24(): number; + get TEXTURE25(): number; + get TEXTURE26(): number; + get TEXTURE27(): number; + get TEXTURE28(): number; + get TEXTURE29(): number; + get TEXTURE30(): number; + get TEXTURE31(): number; + get ACTIVE_TEXTURE(): number; + get REPEAT(): number; + get CLAMP_TO_EDGE(): number; + get MIRRORED_REPEAT(): number; + get FLOAT_VEC2(): number; + get FLOAT_VEC3(): number; + get FLOAT_VEC4(): number; + get INT_VEC2(): number; + get INT_VEC3(): number; + get INT_VEC4(): number; + get BOOL(): number; + get BOOL_VEC2(): number; + get BOOL_VEC3(): number; + get BOOL_VEC4(): number; + get FLOAT_MAT2(): number; + get FLOAT_MAT3(): number; + get FLOAT_MAT4(): number; + get SAMPLER_2D(): number; + get SAMPLER_CUBE(): number; + get LOW_FLOAT(): number; + get MEDIUM_FLOAT(): number; + get HIGH_FLOAT(): number; + get LOW_INT(): number; + get MEDIUM_INT(): number; + get HIGH_INT(): number; + get FRAMEBUFFER(): number; + get RENDERBUFFER(): number; + get RGBA4(): number; + get RGB5_A1(): number; + get RGB565(): number; + get DEPTH_COMPONENT16(): number; + get STENCIL_INDEX8(): number; + get DEPTH_STENCIL(): number; + get RENDERBUFFER_WIDTH(): number; + get RENDERBUFFER_HEIGHT(): number; + get RENDERBUFFER_INTERNAL_FORMAT(): number; + get RENDERBUFFER_RED_SIZE(): number; + get RENDERBUFFER_GREEN_SIZE(): number; + get RENDERBUFFER_BLUE_SIZE(): number; + get RENDERBUFFER_ALPHA_SIZE(): number; + get RENDERBUFFER_DEPTH_SIZE(): number; + get RENDERBUFFER_STENCIL_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE(): number; + get FRAMEBUFFER_ATTACHMENT_OBJECT_NAME(): number; + get FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL(): number; + get FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE(): number; + get COLOR_ATTACHMENT0(): number; + get DEPTH_ATTACHMENT(): number; + get STENCIL_ATTACHMENT(): number; + get DEPTH_STENCIL_ATTACHMENT(): number; + get NONE(): number; + get FRAMEBUFFER_COMPLETE(): number; + get FRAMEBUFFER_INCOMPLETE_ATTACHMENT(): number; + get FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT(): number; + get FRAMEBUFFER_INCOMPLETE_DIMENSIONS(): number; + get FRAMEBUFFER_UNSUPPORTED(): number; + get FRAMEBUFFER_BINDING(): number; + get RENDERBUFFER_BINDING(): number; + get MAX_RENDERBUFFER_SIZE(): number; + get INVALID_FRAMEBUFFER_OPERATION(): number; + get UNPACK_FLIP_Y_WEBGL(): number; + get UNPACK_PREMULTIPLY_ALPHA_WEBGL(): number; + get UNPACK_COLORSPACE_CONVERSION_WEBGL(): number; + get READ_BUFFER(): number; + get UNPACK_ROW_LENGTH(): number; + get UNPACK_SKIP_ROWS(): number; + get UNPACK_SKIP_PIXELS(): number; + get PACK_ROW_LENGTH(): number; + get PACK_SKIP_ROWS(): number; + get PACK_SKIP_PIXELS(): number; + get TEXTURE_BINDING_3D(): number; + get UNPACK_SKIP_IMAGES(): number; + get UNPACK_IMAGE_HEIGHT(): number; + get MAX_3D_TEXTURE_SIZE(): number; + get MAX_ELEMENTS_VERTICES(): number; + get MAX_ELEMENTS_INDICES(): number; + get MAX_TEXTURE_LOD_BIAS(): number; + get MAX_FRAGMENT_UNIFORM_COMPONENTS(): number; + get MAX_VERTEX_UNIFORM_COMPONENTS(): number; + get MAX_ARRAY_TEXTURE_LAYERS(): number; + get MIN_PROGRAM_TEXEL_OFFSET(): number; + get MAX_PROGRAM_TEXEL_OFFSET(): number; + get MAX_VARYING_COMPONENTS(): number; + get FRAGMENT_SHADER_DERIVATIVE_HINT(): number; + get RASTERIZER_DISCARD(): number; + get VERTEX_ARRAY_BINDING(): number; + get MAX_VERTEX_OUTPUT_COMPONENTS(): number; + get MAX_FRAGMENT_INPUT_COMPONENTS(): number; + get MAX_SERVER_WAIT_TIMEOUT(): number; + get MAX_ELEMENT_INDEX(): number; + get RED(): number; + get RGB8(): number; + get RGBA8(): number; + get RGB10_A2(): number; + get TEXTURE_3D(): number; + get TEXTURE_WRAP_R(): number; + get TEXTURE_MIN_LOD(): number; + get TEXTURE_MAX_LOD(): number; + get TEXTURE_BASE_LEVEL(): number; + get TEXTURE_MAX_LEVEL(): number; + get TEXTURE_COMPARE_MODE(): number; + get TEXTURE_COMPARE_FUNC(): number; + get SRGB(): number; + get SRGB8(): number; + get SRGB8_ALPHA8(): number; + get COMPARE_REF_TO_TEXTURE(): number; + get RGBA32F(): number; + get RGB32F(): number; + get RGBA16F(): number; + get RGB16F(): number; + get TEXTURE_2D_ARRAY(): number; + get TEXTURE_BINDING_2D_ARRAY(): number; + get R11F_G11F_B10F(): number; + get RGB9_E5(): number; + get RGBA32UI(): number; + get RGB32UI(): number; + get RGBA16UI(): number; + get RGB16UI(): number; + get RGBA8UI(): number; + get RGB8UI(): number; + get RGBA32I(): number; + get RGB32I(): number; + get RGBA16I(): number; + get RGB16I(): number; + get RGBA8I(): number; + get RGB8I(): number; + get RED_INTEGER(): number; + get RGB_INTEGER(): number; + get RGBA_INTEGER(): number; + get R8(): number; + get RG8(): number; + get R16F(): number; + get R32F(): number; + get RG16F(): number; + get RG32F(): number; + get R8I(): number; + get R8UI(): number; + get R16I(): number; + get R16UI(): number; + get R32I(): number; + get R32UI(): number; + get RG8I(): number; + get RG8UI(): number; + get RG16I(): number; + get RG16UI(): number; + get RG32I(): number; + get RG32UI(): number; + get R8_SNORM(): number; + get RG8_SNORM(): number; + get RGB8_SNORM(): number; + get RGBA8_SNORM(): number; + get RGB10_A2UI(): number; + get TEXTURE_IMMUTABLE_FORMAT(): number; + get TEXTURE_IMMUTABLE_LEVELS(): number; + get UNSIGNED_INT_2_10_10_10_REV(): number; + get UNSIGNED_INT_10F_11F_11F_REV(): number; + get UNSIGNED_INT_5_9_9_9_REV(): number; + get FLOAT_32_UNSIGNED_INT_24_8_REV(): number; + get UNSIGNED_INT_24_8(): number; + get HALF_FLOAT(): number; + get RG(): number; + get RG_INTEGER(): number; + get INT_2_10_10_10_REV(): number; + get QUERY_RESULT_AVAILABLE(): number; + get QUERY_RESULT(): number; + get CURRENT_QUERY(): number; + get ANY_SAMPLES_PASSED(): number; + get ANY_SAMPLES_PASSED_CONSERVATIVE(): number; + get MAX_DRAW_BUFFERS(): number; + get DRAW_BUFFER0(): number; + get DRAW_BUFFER1(): number; + get DRAW_BUFFER2(): number; + get DRAW_BUFFER3(): number; + get DRAW_BUFFER4(): number; + get DRAW_BUFFER5(): number; + get DRAW_BUFFER6(): number; + get DRAW_BUFFER7(): number; + get DRAW_BUFFER8(): number; + get DRAW_BUFFER9(): number; + get DRAW_BUFFER10(): number; + get DRAW_BUFFER11(): number; + get DRAW_BUFFER12(): number; + get DRAW_BUFFER13(): number; + get DRAW_BUFFER14(): number; + get DRAW_BUFFER15(): number; + get MAX_COLOR_ATTACHMENTS(): number; + get COLOR_ATTACHMENT1(): number; + get COLOR_ATTACHMENT2(): number; + get COLOR_ATTACHMENT3(): number; + get COLOR_ATTACHMENT4(): number; + get COLOR_ATTACHMENT5(): number; + get COLOR_ATTACHMENT6(): number; + get COLOR_ATTACHMENT7(): number; + get COLOR_ATTACHMENT8(): number; + get COLOR_ATTACHMENT9(): number; + get COLOR_ATTACHMENT10(): number; + get COLOR_ATTACHMENT11(): number; + get COLOR_ATTACHMENT12(): number; + get COLOR_ATTACHMENT13(): number; + get COLOR_ATTACHMENT14(): number; + get COLOR_ATTACHMENT15(): number; + get SAMPLER_3D(): number; + get SAMPLER_2D_SHADOW(): number; + get SAMPLER_2D_ARRAY(): number; + get SAMPLER_2D_ARRAY_SHADOW(): number; + get SAMPLER_CUBE_SHADOW(): number; + get INT_SAMPLER_2D(): number; + get INT_SAMPLER_3D(): number; + get INT_SAMPLER_CUBE(): number; + get INT_SAMPLER_2D_ARRAY(): number; + get UNSIGNED_INT_SAMPLER_2D(): number; + get UNSIGNED_INT_SAMPLER_3D(): number; + get UNSIGNED_INT_SAMPLER_CUBE(): number; + get UNSIGNED_INT_SAMPLER_2D_ARRAY(): number; + get MAX_SAMPLES(): number; + get SAMPLER_BINDING(): number; + get PIXEL_PACK_BUFFER(): number; + get PIXEL_UNPACK_BUFFER(): number; + get PIXEL_PACK_BUFFER_BINDING(): number; + get PIXEL_UNPACK_BUFFER_BINDING(): number; + get COPY_READ_BUFFER(): number; + get COPY_WRITE_BUFFER(): number; + get COPY_READ_BUFFER_BINDING(): number; + get COPY_WRITE_BUFFER_BINDING(): number; + get FLOAT_MAT2x3(): number; + get FLOAT_MAT2x4(): number; + get FLOAT_MAT3x2(): number; + get FLOAT_MAT3x4(): number; + get FLOAT_MAT4x2(): number; + get FLOAT_MAT4x3(): number; + get UNSIGNED_INT_VEC2(): number; + get UNSIGNED_INT_VEC3(): number; + get UNSIGNED_INT_VEC4(): number; + get UNSIGNED_NORMALIZED(): number; + get SIGNED_NORMALIZED(): number; + get VERTEX_ATTRIB_ARRAY_INTEGER(): number; + get VERTEX_ATTRIB_ARRAY_DIVISOR(): number; + get TRANSFORM_FEEDBACK_BUFFER_MODE(): number; + get MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS(): number; + get TRANSFORM_FEEDBACK_VARYINGS(): number; + get TRANSFORM_FEEDBACK_BUFFER_START(): number; + get TRANSFORM_FEEDBACK_BUFFER_SIZE(): number; + get TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN(): number; + get MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS(): number; + get MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS(): number; + get INTERLEAVED_ATTRIBS(): number; + get SEPARATE_ATTRIBS(): number; + get TRANSFORM_FEEDBACK_BUFFER(): number; + get TRANSFORM_FEEDBACK_BUFFER_BINDING(): number; + get TRANSFORM_FEEDBACK(): number; + get TRANSFORM_FEEDBACK_PAUSED(): number; + get TRANSFORM_FEEDBACK_ACTIVE(): number; + get TRANSFORM_FEEDBACK_BINDING(): number; + get FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING(): number; + get FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE(): number; + get FRAMEBUFFER_ATTACHMENT_RED_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_GREEN_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_BLUE_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE(): number; + get FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE(): number; + get FRAMEBUFFER_DEFAULT(): number; + get DEPTH24_STENCIL8(): number; + get DRAW_FRAMEBUFFER_BINDING(): number; + get READ_FRAMEBUFFER(): number; + get DRAW_FRAMEBUFFER(): number; + get READ_FRAMEBUFFER_BINDING(): number; + get RENDERBUFFER_SAMPLES(): number; + get FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER(): number; + get FRAMEBUFFER_INCOMPLETE_MULTISAMPLE(): number; + get UNIFORM_BUFFER(): number; + get UNIFORM_BUFFER_BINDING(): number; + get UNIFORM_BUFFER_START(): number; + get UNIFORM_BUFFER_SIZE(): number; + get MAX_VERTEX_UNIFORM_BLOCKS(): number; + get MAX_FRAGMENT_UNIFORM_BLOCKS(): number; + get MAX_COMBINED_UNIFORM_BLOCKS(): number; + get MAX_UNIFORM_BUFFER_BINDINGS(): number; + get MAX_UNIFORM_BLOCK_SIZE(): number; + get MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS(): number; + get MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS(): number; + get UNIFORM_BUFFER_OFFSET_ALIGNMENT(): number; + get ACTIVE_UNIFORM_BLOCKS(): number; + get UNIFORM_TYPE(): number; + get UNIFORM_SIZE(): number; + get UNIFORM_BLOCK_INDEX(): number; + get UNIFORM_OFFSET(): number; + get UNIFORM_ARRAY_STRIDE(): number; + get UNIFORM_MATRIX_STRIDE(): number; + get UNIFORM_IS_ROW_MAJOR(): number; + get UNIFORM_BLOCK_BINDING(): number; + get UNIFORM_BLOCK_DATA_SIZE(): number; + get UNIFORM_BLOCK_ACTIVE_UNIFORMS(): number; + get UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES(): number; + get UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER(): number; + get UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER(): number; + get OBJECT_TYPE(): number; + get SYNC_CONDITION(): number; + get SYNC_STATUS(): number; + get SYNC_FLAGS(): number; + get SYNC_FENCE(): number; + get SYNC_GPU_COMMANDS_COMPLETE(): number; + get UNSIGNALED(): number; + get SIGNALED(): number; + get ALREADY_SIGNALED(): number; + get TIMEOUT_EXPIRED(): number; + get CONDITION_SATISFIED(): number; + get WAIT_FAILED(): number; + get SYNC_FLUSH_COMMANDS_BIT(): number; + get COLOR(): number; + get DEPTH(): number; + get STENCIL(): number; + get MIN(): number; + get MAX(): number; + get DEPTH_COMPONENT24(): number; + get STREAM_READ(): number; + get STREAM_COPY(): number; + get STATIC_READ(): number; + get STATIC_COPY(): number; + get DYNAMIC_READ(): number; + get DYNAMIC_COPY(): number; + get DEPTH_COMPONENT32F(): number; + get DEPTH32F_STENCIL8(): number; + get INVALID_INDEX(): number; + get TIMEOUT_IGNORED(): number; + get MAX_CLIENT_WAIT_TIMEOUT_WEBGL(): number; +} diff --git a/napi/canvas-napi/index.js b/napi/canvas-napi/index.js index d35631c9d..ec07cc03a 100644 --- a/napi/canvas-napi/index.js +++ b/napi/canvas-napi/index.js @@ -331,6 +331,11 @@ const { GPU, TextEncoder, TextDecoder, + WebGLQuery, + WebGLSampler, + WebGLTransformFeedback, + WebGLVertexArrayObject, + WebGLSync, WebGL2RenderingContext, } = nativeBinding; @@ -380,4 +385,9 @@ module.exports.GPUCanvasContext = GPUCanvasContext; module.exports.GPU = GPU; module.exports.TextEncoder = TextEncoder; module.exports.TextDecoder = TextDecoder; +module.exports.WebGLQuery = WebGLQuery; +module.exports.WebGLSampler = WebGLSampler; +module.exports.WebGLTransformFeedback = WebGLTransformFeedback; +module.exports.WebGLVertexArrayObject = WebGLVertexArrayObject; +module.exports.WebGLSync = WebGLSync; module.exports.WebGL2RenderingContext = WebGL2RenderingContext; diff --git a/napi/canvas-napi/main.mjs b/napi/canvas-napi/main.mjs index d86593787..dd92b1908 100644 --- a/napi/canvas-napi/main.mjs +++ b/napi/canvas-napi/main.mjs @@ -1,5 +1,7 @@ import '@nativescript/macos-node-api'; -import { CanvasRenderingContext2D, ImageAsset, TextDecoder, TextEncoder, WebGLRenderingContext } from './index.js'; +import { CanvasRenderingContext2D, ImageAsset, TextDecoder, TextEncoder, WebGLRenderingContext, WebGL2RenderingContext } from './index.js'; +import { cancelAnimationFrame, requestAnimationFrame } from './utils/index.js'; +import { Canvas } from './canvas.js'; objc.import('AppKit'); objc.import('OpenGL'); @@ -69,12 +71,10 @@ class Application { NativeScriptApplication.window = window; - window.becomeMainWindow(); window.displayIfNeeded(); window.makeKeyAndOrderFront(NSApp); - Application.application = NSApplication.sharedApplication; Application.delegate = ApplicationDelegate.new(); Application.delegate.window = NativeScriptApplication.window.nativeView; @@ -157,9 +157,9 @@ export class ApplicationDelegate extends NSObject { RunLoop(); - //doTheThing(); + doTheThing(); - doGL(); + //doGL(); } applicationWillTerminate(_notification) { @@ -181,92 +181,7 @@ export class ApplicationDelegate extends NSObject { } } -export class NSCMTLView extends NSView { - static { - NativeClass(this); - } - _device; - _queue; - _canvas; - - get queue() { - return this._queue; - } - - get device() { - return this._device; - } - - initWithFrame(frameRect) { - super.initWithFrame(frameRect); - this.wantsLayer = true; - const layer = CAMetalLayer.layer(); - this._device = MTLCreateSystemDefaultDevice(); - this._queue = this._device.newCommandQueue(); - layer.device = this._device; - layer.presentsWithTransaction = false; - layer.framebufferOnly = false; - layer.pixelFormat = MTLPixelFormat.BGRA8Unorm; - - this.layer = layer; - return this; - } - - /** - * @return {CGSize} - */ - get drawableSize() { - return this.layer.drawableSize; - } - - /** - * @param {CGSize} value - */ - set drawableSize(value) { - this.layer.drawableSize = value; - } - - present() { - this._canvas?.getContext('2d').flush(); - this._canvas?.getContext('2d').present(); - } - - static ObjCExposedMethods = { - present: { returns: interop.types.void, params: [] } - }; -} - -export class NSCCanvas extends NSView { - static { - NativeClass(this); - } -} - -export class CanvasGLView extends NSOpenGLView { - static { - NativeClass(this); - } - isDirty = false; - /** - * @param {NSCCanvas} canvas - */ - canvas = null; - - initWithFrame(frame) { - super.initWithFrame(frame); - this.wantsLayer = true; - return this; - } - - prepareOpenGL() { - super.prepareOpenGL(); - } - - clearGLContext() { - super.clearGLContext(); - } -} - +const canvasView = new Canvas(); export class ViewController extends NSViewController { static { NativeClass(this); @@ -279,30 +194,18 @@ export class ViewController extends NSViewController { */ viewDidLoad() { super.viewDidLoad(); - this.canvas = NSCCanvas.alloc().initWithFrame(this.view.frame); - - glview.frame = this.view.frame; - mtlview.frame = this.view.frame; - mtlview.drawableSize = new CGSize({ + this.canvas = canvasView; + const dim = { width: this.view.frame.size.width * NSScreen.mainScreen.backingScaleFactor, - height: this.view.frame.size.height * NSScreen.mainScreen.backingScaleFactor - }); - - // this.canvas.addSubview(mtlview); - - glview.layer.backgroundColor = NSColor.blueColor; - - this.canvas.addSubview(glview); - - this.view.addSubview(this.canvas); + height: this.view.frame.size.height * NSScreen.mainScreen.backingScaleFactor, + }; + this.canvas.width = dim.width; + this.canvas.height = dim.height; + this.view.addSubview(this.canvas.nativeView); } } -const glview = CanvasGLView.alloc().initWithFrame({ x: 0, y: 0, width: 0, height: 0 }); - -const mtlview = NSCMTLView.alloc().initWithFrame({ x: 0, y: 0, width: 0, height: 0 }); - let isDoingOrDone = false; function mdnShadowColor(ctx) { @@ -398,39 +301,6 @@ function mdnCreateConicGradient(ctx) { ctx.fillRect(20, 20, 200, 200); } -let requestAnimationFrameFunc; - -class CADisplayLinkImpl extends NSObject { - static ObjCProtocols = [NSApplicationDelegate, NSWindowDelegate]; - - static { - NativeClass(this); - } - - handleFrame(link) { - requestAnimationFrameFunc?.(link.timestamp); - //requestAnimationFrameFunc = null; - } - - static ObjCExposedMethods = { - handleFrame: { returns: interop.types.void, params: [CADisplayLink] } - }; -} - -const impl = CADisplayLinkImpl.new(); - -const displayLink = NSScreen.mainScreen.displayLinkWithTargetSelector(impl, 'handleFrame'); -displayLink.paused = true; -displayLink.addToRunLoopForMode(NSRunLoop.currentRunLoop, NSDefaultRunLoopMode); - -function requestAnimationFrame(func) { - if (displayLink.paused) { - displayLink.paused = false; - } - requestAnimationFrameFunc = func; - return 1; -} - function flappyBird(canvas) { var ctx, width, @@ -443,7 +313,7 @@ function flappyBird(canvas) { states = { Splash: 0, Game: 1, - Score: 2 + Score: 2, }, okbtn, bird = { @@ -457,11 +327,11 @@ function flappyBird(canvas) { gravity: 0.25, _jump: 4.6, - jump: function() { + jump: function () { this.velocity = -this._jump; }, - update: function() { + update: function () { var n = currentstate === states.Splash ? 10 : 5; this.frame += frames % n === 0 ? 1 : 0; this.frame %= this.animation.length; @@ -490,7 +360,7 @@ function flappyBird(canvas) { } }, - draw: function(ctx) { + draw: function (ctx) { ctx.save(); ctx.translate(this.x, this.y); ctx.rotate(this.rotation); @@ -498,23 +368,23 @@ function flappyBird(canvas) { var n = this.animation[this.frame]; s_bird[n].draw(ctx, -s_bird[n].width / 2, -s_bird[n].height / 2); ctx.restore(); - } + }, }, pipes = { _pipes: [], - reset: function() { + reset: function () { this._pipes = []; }, - update: function() { + update: function () { if (frames % 100 === 0) { var _y = height - (s_pipeSouth.height + s_fg.height + 120 + 200 * Math.random()); this._pipes.push({ x: 500, y: _y, width: s_pipeSouth.width, - height: s_pipeSouth.height + height: s_pipeSouth.height, }); } for (var i = 0, len = this._pipes.length; i < len; i++) { @@ -550,13 +420,13 @@ function flappyBird(canvas) { } }, - draw: function(...args) { + draw: function (...args) { for (var i = 0, len = this._pipes.length; i < len; i++) { var p = this._pipes[i]; s_pipeSouth.draw(ctx, p.x, p.y); s_pipeNorth.draw(ctx, p.x, p.y + 80 + p.height); } - } + }, }, img; @@ -618,7 +488,7 @@ function flappyBird(canvas) { x: (width - s_buttons.Ok.width) / 2, y: height - 200, width: s_buttons.Ok.width, - height: s_buttons.Ok.height + height: s_buttons.Ok.height, }; run(); @@ -643,7 +513,7 @@ function flappyBird(canvas) { } function run() { - var loop = function(ts) { + var loop = function (ts) { render(); update(); requestAnimationFrame(loop); @@ -710,7 +580,7 @@ function flappyBird(canvas) { this.height = height * 2; } - Sprite.prototype.draw = function(ctx, x, y) { + Sprite.prototype.draw = function (ctx, x, y) { ctx.drawImage(this.img, this.x, this.y, this.width, this.height, x, y, this.width, this.height); }; @@ -727,7 +597,7 @@ function flappyBird(canvas) { s_text = { FlappyBird: new Sprite(img, 59, 114, 96, 22), GameOver: new Sprite(img, 59, 136, 94, 19), - GetReady: new Sprite(img, 59, 155, 87, 22) + GetReady: new Sprite(img, 59, 155, 87, 22), }; s_buttons = { Rate: new Sprite(img, 79, 177, 40, 14), @@ -735,7 +605,7 @@ function flappyBird(canvas) { Share: new Sprite(img, 159, 177, 40, 14), Score: new Sprite(img, 79, 191, 40, 14), Ok: new Sprite(img, 119, 191, 40, 14), - Start: new Sprite(img, 159, 191, 40, 14) + Start: new Sprite(img, 159, 191, 40, 14), }; s_score = new Sprite(img, 138, 56, 113, 58); @@ -744,7 +614,7 @@ function flappyBird(canvas) { s_numberS = new Sprite(img, 0, 177, 6, 7); s_numberB = new Sprite(img, 0, 188, 7, 10); - s_numberS.draw = s_numberB.draw = function(ctx, x, y, num, center, offset) { + s_numberS.draw = s_numberB.draw = function (ctx, x, y, num, center, offset) { num = num.toString(); var step = this.width + 2; @@ -790,13 +660,13 @@ function solarSystem(canvas) { moon = new ImageAsset(); earth = new ImageAsset(); - await sun.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_sun.png'); - await moon.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_moon.png'); - await earth.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_earth.png'); + // await sun.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_sun.png'); + // await moon.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_moon.png'); + // await earth.fromUrl('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_earth.png'); - // sun.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_sun.png'); - // moon.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_moon.png'); - // earth.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_earth.png'); + sun.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_sun.png'); + moon.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_moon.png'); + earth.fromUrlSync('https://raw.githubusercontent.com/NativeScript/canvas/refs/heads/feat/macos-napi/napi/canvas-napi/examples/assets/canvas_earth.png'); LAF = requestAnimationFrame(draw); } @@ -846,13 +716,13 @@ function solarSystem(canvas) { let LAF = 0; const window = { - devicePixelRatio: NSScreen.mainScreen.backingScaleFactor + devicePixelRatio: NSScreen.mainScreen.backingScaleFactor, }; const Screen = { mainScreen: { - scale: NSScreen.mainScreen.backingScaleFactor - } + scale: NSScreen.mainScreen.backingScaleFactor, + }, }; function swarm(canvas, width, height, nativeCanvas) { @@ -930,7 +800,7 @@ function swarm(canvas, width, height, nativeCanvas) { // end angle and finally a boolean value which decides // whether the arc is to be drawn in counter clockwise or // in a clockwise direction. False for clockwise. - this.draw = function() { + this.draw = function () { ctx.fillStyle = 'white'; ctx.beginPath(); ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2, false); @@ -1062,7 +932,7 @@ function breathe_demo(canvas) { const polar2Cartesian = (p) => { return { x: p.radius * Math.cos(p.theta), - y: p.radius * Math.sin(p.theta) + y: p.radius * Math.sin(p.theta), }; }; @@ -1317,11 +1187,9 @@ void main() { } textures(canvas); - } function createChaosLines(canvas) { - function createShader(gl, type, source) { var shader = gl.createShader(type); gl.shaderSource(shader, source); @@ -1503,7 +1371,6 @@ function createChaosLines(canvas) { initWebGL(canvas); } - function cubeRotation(canvas) { let LAF = 0; @@ -1549,12 +1416,7 @@ function cubeRotation(canvas) { 'vColor = color;' + '}'; - var fragCode = - '#version 330 core\n' + - 'precision mediump float;' + - 'out vec3 vColor;' + - 'out vec4 fragColor;' + - 'void main(void) {' + 'fragColor = vec4(vColor, 1.0);' + '}'; + var fragCode = '#version 330 core\n' + 'precision mediump float;' + 'out vec3 vColor;' + 'out vec4 fragColor;' + 'void main(void) {' + 'fragColor = vec4(vColor, 1.0);' + '}'; var vertShader = gl.createShader(gl.VERTEX_SHADER); gl.shaderSource(vertShader, vertCode); @@ -1564,27 +1426,24 @@ function cubeRotation(canvas) { if (!compiled) { // Something went wrong during compilation; get the error const lastError = gl.getShaderInfoLog(vertShader); - console.log('*** Error compiling shader \'' + vertShader + '\':' + lastError); + console.log("*** Error compiling shader '" + vertShader + "':" + lastError); gl.deleteShader(vertShader); return null; } - var fragShader = gl.createShader(gl.FRAGMENT_SHADER); gl.shaderSource(fragShader, fragCode); gl.compileShader(fragShader); - compiled = gl.getShaderParameter(fragShader, gl.COMPILE_STATUS); if (!compiled) { // Something went wrong during compilation; get the error const lastError = gl.getShaderInfoLog(fragShader); - console.log('*** Error compiling shader \'' + fragShader + '\':' + lastError); + console.log("*** Error compiling shader '" + fragShader + "':" + lastError); gl.deleteShader(fragShader); return null; } - var shaderProgram = gl.createProgram(); gl.attachShader(shaderProgram, vertShader); gl.attachShader(shaderProgram, fragShader); @@ -1596,13 +1455,11 @@ function cubeRotation(canvas) { return; } - /* ====== Associating attributes to vertex shader =====*/ var Pmatrix = gl.getUniformLocation(shaderProgram, 'Pmatrix'); var Vmatrix = gl.getUniformLocation(shaderProgram, 'Vmatrix'); var Mmatrix = gl.getUniformLocation(shaderProgram, 'Mmatrix'); - gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer); var position = gl.getAttribLocation(shaderProgram, 'position'); gl.vertexAttribPointer(position, 3, gl.FLOAT, false, 0, 0); @@ -1685,7 +1542,7 @@ function cubeRotation(canvas) { /*================= Drawing ===========================*/ var time_old = 0; - var animate = function(time) { + var animate = function (time) { var dt = time - time_old; rotateZ(mov_matrix, dt * 0.005); //time rotateY(mov_matrix, dt * 0.002); @@ -1713,7 +1570,6 @@ function cubeRotation(canvas) { } rotation(canvas); - } function doGL() { @@ -1722,32 +1578,9 @@ function doGL() { // loaded = asset.fromUrlSync('https://www.superherotoystore.com/cdn/shop/articles/Website_Blog_creatives_29_1600x.jpg?v=1713945144'); // console.timeEnd('load1'); - const scale = NSScreen.mainScreen.backingScaleFactor; - - const handle = interop.handleof(glview); - const glContext = WebGLRenderingContext.withView(handle.toNumber(), 2, true, false, false, false, 1, true, false, false, false, false, false); - // console.log(glContext, 'drawingBufferWidth', glContext.drawingBufferWidth, 'drawingBufferHeight', glContext.drawingBufferHeight); - - const glCanvas = { - width: glview.frame.size.width, - height: glview.frame.size.height, - clientWidth: glview.frame.size.width, - clientHeight: glview.frame.size.height, - addEventListener: function() { - }, - getContext: function() { - return glContext; - }, - style: {} - }; - - glview._canvas = glCanvas; - - //webglTextures(glCanvas); - //createChaosLines(glCanvas); - cubeRotation(glCanvas); - + createChaosLines(canvasView); + // cubeRotation(glCanvas); } function doTheThing() { @@ -1756,52 +1589,11 @@ function doTheThing() { // loaded = asset.fromUrlSync('https://www.superherotoystore.com/cdn/shop/articles/Website_Blog_creatives_29_1600x.jpg?v=1713945144'); // console.timeEnd('load1'); - const scale = NSScreen.mainScreen.backingScaleFactor; - - console.log('doTheThing'); - - const gl = WebGLRenderingContext.offscreen(600, 300, 1, true, false, false, false, 1, true, false, false, false, false, false); - - console.log('gl', gl); - - console.log(gl.getContextAttributes()); - - - // gl.clearColor(0, 0, 1, 1); - // gl.clear(gl.COLOR_BUFFER_BIT); - // gl.flush(); - - //console.log('gl', gl.toDataURL('image/png')); - - // const glview = CanvasGLView.alloc().initWithFrame(NSMakeRect(0, 0, 300 / scale, 150 / scale)); - // glview.wantsLayer = true; - // glview.prepareOpenGL(); + const canvas = canvasView; - const handle = interop.handleof(glview); - // const glContext = WebGLRenderingContext.withView(handle.toNumber(), 1, true, false, false, false, 1, true, false, false, false, false, false); - // console.log(glContext, 'drawingBufferWidth', glContext.drawingBufferWidth, 'drawingBufferHeight', glContext.drawingBufferHeight); - - //const ctx = CanvasRenderingContext2D.withView(handle.toNumber(), glview.frame.size.width * scale, glview.frame.size.height * scale, 1, true, 0, 90, 1); - - const mtlViewHandle = interop.handleof(mtlview); - const deviceHandle = interop.handleof(mtlview.device); - const queueHandle = interop.handleof(mtlview.queue); - const ctx = CanvasRenderingContext2D.withMtlViewDeviceQueue(mtlViewHandle.toNumber(), deviceHandle.toNumber(), queueHandle.toNumber(), true, scale, 1, 0, 90, 1); - - const mtlCanvas = { - width: mtlview.frame.size.width, - height: mtlview.frame.size.height, - clientWidth: mtlview.frame.size.width, - clientHeight: mtlview.frame.size.height, - addEventListener: function() { - }, - getContext: function() { - return ctx; - }, - style: {} - }; + const scale = NSScreen.mainScreen.backingScaleFactor; - mtlview._canvas = mtlCanvas; + const ctx = canvas.getContext('2d'); ctx.fillStyle = 'white'; @@ -1811,29 +1603,12 @@ function doTheThing() { ctx.scale(scale, scale); - const encoder = new TextEncoder(); - - const decoder = new TextDecoder(); - // ctx.translate(0, 100); //mdnShadowColor(ctx); //mdnRotate(ctx); // mdnCreateConicGradient(ctx); - const canvas = { - width: glview.frame.size.width, - height: glview.frame.size.height, - clientWidth: glview.frame.size.width, - clientHeight: glview.frame.size.height, - addEventListener: function() { - }, - getContext: function() { - return ctx; - }, - style: {} - }; - //flappyBird(mtlCanvas); solarSystem(canvas); diff --git a/napi/canvas-napi/package.json b/napi/canvas-napi/package.json index 678f6d45c..f9aaa15e4 100644 --- a/napi/canvas-napi/package.json +++ b/napi/canvas-napi/package.json @@ -35,6 +35,7 @@ "prepublishOnly": "napi prepublish -t npm", "test": "ava", "universal": "napi universal", - "version": "napi version" + "version": "napi version", + "build-tsc": "tsc -p tsconfig.json" } } diff --git a/napi/canvas-napi/references.d.ts b/napi/canvas-napi/references.d.ts new file mode 100644 index 000000000..02687ea15 --- /dev/null +++ b/napi/canvas-napi/references.d.ts @@ -0,0 +1 @@ +/// diff --git a/napi/canvas-napi/src/gl/base.rs b/napi/canvas-napi/src/gl/base.rs new file mode 100644 index 000000000..f1695dcca --- /dev/null +++ b/napi/canvas-napi/src/gl/base.rs @@ -0,0 +1,1410 @@ +#[macro_export] +macro_rules! impl_webgl_context { + ($struct_name:ident) => { + use crate::webgl_context_imports; + webgl_context_imports!(); + + + const UNPACK_FLIP_Y_WEBGL: u32 = 37440; +const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 = 37441; +const UNPACK_COLOR_SPACE_CONVERSION_WEBGL: u32 = 37443; + + #[napi] + impl $struct_name { + #[napi] + pub fn render(&self) { + canvas_c::canvas_native_webgl_make_current_and_swap_buffers(self.state); + } + + #[napi(getter)] + pub fn get_drawing_buffer_width(&self) -> i32 { + canvas_c::canvas_native_webgl_state_get_drawing_buffer_width(self.state) + } + + #[napi(getter)] + pub fn get_drawing_buffer_height(&self) -> i32 { + canvas_c::canvas_native_webgl_state_get_drawing_buffer_height(self.state) + } + + #[napi] + pub fn active_texture(&self, texture: u32) { + canvas_c::canvas_native_webgl_active_texture(texture, self.state); + } + + #[napi] + pub fn attach_shader( + &self, + program: ClassInstance, + shader: ClassInstance, + ) { + canvas_c::canvas_native_webgl_attach_shader(program.0, shader.0, self.state); + } + + #[napi] + pub fn bind_attrib_location( + &self, + program: ClassInstance, + index: u32, + name: JsString, + ) -> Result<()> { + let name = name.into_utf8()?; + let name = name.as_str()?; + let state = unsafe { &mut *self.state }; + unsafe { + canvas_webgl::webgl::canvas_native_webgl_bind_attrib_location( + program.0, + index, + name, + state.get_inner_mut(), + ) + } + Ok(()) + } + + #[napi] + pub fn bind_buffer(&self, target: u32, buffer: ClassInstance) { + canvas_c::canvas_native_webgl_bind_buffer(target, buffer.0, self.state); + } + + #[napi] + pub fn bind_framebuffer(&self, target: u32, framebuffer: ClassInstance) { + canvas_c::canvas_native_webgl_bind_frame_buffer(target, framebuffer.0, self.state); + } + + #[napi] + pub fn bind_renderbuffer(&self, target: u32, renderbuffer: ClassInstance) { + canvas_c::canvas_native_webgl_bind_render_buffer(target, renderbuffer.0, self.state); + } + + #[napi] + pub fn bind_texture(&self, target: u32, texture: ClassInstance) { + canvas_c::canvas_native_webgl_bind_texture(target, texture.0, self.state); + } + + #[napi] + pub fn blend_color(&self, red: f64, green: f64, blue: f64, alpha: f64) { + canvas_c::canvas_native_webgl_blend_color( + red as f32, + green as f32, + blue as f32, + alpha as f32, + self.state, + ); + } + + #[napi] + pub fn blend_equation_separate(&self, mode_r_g_b: u32, mode_alpha: u32) { + canvas_c::canvas_native_webgl_blend_equation_separate(mode_r_g_b, mode_alpha, self.state) + } + + #[napi] + pub fn blend_equation(&self, mode: u32) { + canvas_c::canvas_native_webgl_blend_equation(mode, self.state) + } + + #[napi] + pub fn blend_func_separate( + &self, + src_r_g_b: Option, + dst_r_g_b: Option, + src_alpha: Option, + dst_alpha: Option, + ) { + let src_r_g_b = src_r_g_b.unwrap_or(1); + let dst_r_g_b = dst_r_g_b.unwrap_or(0); + let src_alpha = src_alpha.unwrap_or(1); + let dst_alpha = dst_alpha.unwrap_or(0); + canvas_c::canvas_native_webgl_blend_func_separate( + src_r_g_b, dst_r_g_b, src_alpha, dst_alpha, self.state, + ); + } + + #[napi] + pub fn blend_func(&self, sfactor: Option, dfactor: Option) { + let sfactor = sfactor.unwrap_or(1); + let dfactor = dfactor.unwrap_or(0); + canvas_c::canvas_native_webgl_blend_func(sfactor, dfactor, self.state); + } + + #[napi] + pub fn buffer_data( + &self, + target: u32, + size_or_src_data: Option>, + usage: Option, + ) { + match size_or_src_data { + Some(size_or_src_data) => match size_or_src_data { + Either::A(size) => match usage { + Some(usage) => { + canvas_c::canvas_native_webgl_buffer_data_none( + target, + size as isize, + usage, + self.state, + ); + } + None => { + canvas_c::canvas_native_webgl_buffer_data_none(target, 0, size as u32, self.state); + } + }, + Either::B(src_data) => { + if let Some(usage) = usage { + canvas_c::canvas_native_webgl_buffer_data( + target, + src_data.as_ptr(), + src_data.len(), + usage, + self.state, + ); + } + } + }, + _ => { + if let Some(usage) = usage { + canvas_c::canvas_native_webgl_buffer_data_none(target, 0, usage, self.state); + } + } + } + } + + #[napi] + pub fn buffer_sub_data(&self, target: u32, offset: i64, src_data: &[u8]) { + canvas_c::canvas_native_webgl_buffer_sub_data( + target, + offset as isize, + src_data.as_ptr(), + src_data.len(), + self.state, + ) + } + + + #[napi] + pub fn check_framebuffer_status(&self, target: u32) -> u32 { + canvas_c::canvas_native_webgl_check_frame_buffer_status(target, self.state) + } + + #[napi] + pub fn clear_color(&self, + red: f64, + green: f64, + blue: f64, + alpha: f64) { + canvas_c::canvas_native_webgl_clear_color(red as f32, green as f32, blue as f32, alpha as f32, self.state); + } + + #[napi] + pub fn clear_depth(&self, depth: f64) { + canvas_c::canvas_native_webgl_clear_depth(depth as f32, self.state); + } + + #[napi] + pub fn clear_stencil(&self, stencil: i32) { + canvas_c::canvas_native_webgl_clear_stencil(stencil, self.state); + } + + #[napi] + pub fn clear(&self, mask: u32) { + canvas_c::canvas_native_webgl_clear(mask, self.state); + } + + #[napi] + pub fn color_mask(&self, red: bool, green: bool, blue: bool, alpha: bool) { + canvas_c::canvas_native_webgl_color_mask(red, green, blue, alpha, self.state); + } + + + #[napi] + pub fn commit(&self) { + canvas_c::canvas_native_webgl_commit(self.state); + } + + #[napi] + pub fn compile_shader(&self, shader: ClassInstance) { + canvas_c::canvas_native_webgl_compile_shader(shader.0, self.state); + } + + #[napi] + pub fn compressed_tex_image_2_d(&self, target: u32, level: i32, internalformat: u32, width: i64, height: i64, border: i32, pixels: &[u8]) { + canvas_c::canvas_native_webgl_compressed_tex_image2d( + target, level, internalformat, width as i32, height as i32, border, pixels.as_ptr(), pixels.len(), self.state, + ) + } + + #[napi] + pub fn compressed_tex_sub_image_2_d(&self, target: u32, level: i32, xoffset: i64, yoffset: i64, width: f64, height: f64, format: u32, pixels: &[u8]) { + canvas_c::canvas_native_webgl_compressed_tex_sub_image2d( + target, level, xoffset as i32, yoffset as i32, width as i32, height as i32, format, pixels.as_ptr(), pixels.len(), self.state, + ) + } + + #[napi] + pub fn copy_tex_image_2_d(&self, target: u32, level: i32, internalformat: u32, x: i64, y: i64, width: i64, height: i64, border: i32) { + canvas_c::canvas_native_webgl_copy_tex_image2d( + target, level, internalformat, x as i32, y as i32, width as i32, height as i32, border, self.state, + ) + } + + #[napi] + pub fn copy_tex_sub_image_2_d(&self, target: u32, level: i32, xoffset: i64, yoffset: i64, x: i64, y: i64, width: i64, height: i64) { + canvas_c::canvas_native_webgl_copy_tex_sub_image2d( + target, level, xoffset as i32, yoffset as i32, x as i32, y as i32, width as i32, height as i32, self.state, + ) + } + + #[napi] + pub fn create_buffer(&self, env: Env) -> Result> { + WebGLBuffer( + canvas_c::canvas_native_webgl_create_buffer(self.state) + ).into_instance(env) + } + + #[napi] + pub fn create_framebuffer(&self, env: Env) -> Result> { + WebGLFramebuffer(canvas_c::canvas_native_webgl_create_framebuffer(self.state)) + .into_instance(env) + } + + #[napi] + pub fn create_program(&self, env: Env) -> Result> { + WebGLProgram( + canvas_c::canvas_native_webgl_create_program(self.state) + ).into_instance(env) + } + #[napi] + + pub fn create_renderbuffer(&self, env: Env) -> Result> { + WebGLRenderbuffer( + canvas_c::canvas_native_webgl_create_renderbuffer(self.state) + ).into_instance(env) + } + + #[napi(ts_args_type = "type: number")] + pub fn create_shader(&self, env: Env, type_: u32) -> Result> { + WebGLShader( + canvas_c::canvas_native_webgl_create_shader(type_, self.state), + ).into_instance(env) + } + + #[napi] + pub fn create_texture(&self, env: Env) -> Result> { + WebGLTexture( + canvas_c::canvas_native_webgl_create_texture(self.state) + ).into_instance(env) + } + + #[napi] + pub fn cull_face(&self, mode: u32) { + canvas_c::canvas_native_webgl_cull_face(mode, self.state) + } + + + #[napi] + pub fn delete_buffer(&self, buffer: ClassInstance) { + canvas_c::canvas_native_webgl_delete_buffer(buffer.0, self.state) + } + + #[napi] + pub fn delete_framebuffer(&self, frame_buffer: ClassInstance) { + canvas_c::canvas_native_webgl_delete_framebuffer(frame_buffer.0, self.state) + } + + #[napi] + pub fn delete_program(&self, program: ClassInstance) { + canvas_c::canvas_native_webgl_delete_program(program.0, self.state) + } + + #[napi] + pub fn delete_renderbuffer(&self, render_buffer: ClassInstance) { + canvas_c::canvas_native_webgl_delete_renderbuffer(render_buffer.0, self.state) + } + + #[napi] + pub fn delete_shader(&self, shader: ClassInstance) { + canvas_c::canvas_native_webgl_delete_shader(shader.0, self.state) + } + + #[napi] + pub fn delete_texture(&self, texture: ClassInstance) { + canvas_c::canvas_native_webgl_delete_texture(texture.0, self.state) + } + + #[napi] + pub fn depth_func(&self, func: u32) { + canvas_c::canvas_native_webgl_depth_func(func, self.state); + } + + #[napi] + pub fn depth_mask(&self, flag: bool) { + canvas_c::canvas_native_webgl_depth_mask(flag, self.state); + } + + #[napi] + pub fn depth_range(&self, z_near: f64, z_far: f64) { + canvas_c::canvas_native_webgl_depth_range(z_near as f32, z_far as f32, self.state) + } + + #[napi] + pub fn detach_shader(&self, program: ClassInstance, shader: ClassInstance) { + canvas_c::canvas_native_webgl_detach_shader(program.0, shader.0, self.state) + } + + #[napi] + pub fn disable_vertex_attrib_array(&self, index: u32) { + canvas_c::canvas_native_webgl_disable_vertex_attrib_array(index, self.state); + } + + #[napi] + pub fn disable(&self, cap: u32) { + canvas_c::canvas_native_webgl_disable(cap, self.state); + } + + #[napi] + pub fn draw_arrays(&self, mode: u32, first: i32, count: i32) { + canvas_c::canvas_native_webgl_draw_arrays(mode, first, count, self.state); + } + + #[napi(ts_args_type = "mode: number, count: number, type: number, offset: number")] + pub fn draw_elements(&self, mode: u32, count: i32, type_: u32, offset: i64) { + canvas_c::canvas_native_webgl_draw_elements(mode, count, type_, offset as isize, self.state); + } + + #[napi] + pub fn enable_vertex_attrib_array(&self, index: u32) { + canvas_c::canvas_native_webgl_enable_vertex_attrib_array(index, self.state); + } + + #[napi] + pub fn enable(&self, cap: u32) { + canvas_c::canvas_native_webgl_enable(cap, self.state); + } + + #[napi] + pub fn finish(&self) { + canvas_c::canvas_native_webgl_finish(self.state); + } + + #[napi] + pub fn flush(&self) { + canvas_c::canvas_native_webgl_flush(self.state); + } + + #[napi] + pub fn framebuffer_renderbuffer(&self, target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: ClassInstance) { + canvas_c::canvas_native_webgl_framebuffer_renderbuffer(target, attachment, renderbuffertarget, renderbuffer.0, self.state) + } + + #[napi] + pub fn framebuffer_texture_2_d(&self, target: u32, attachment: u32, textarget: u32, texture: ClassInstance, level: i32) { + canvas_c::canvas_native_webgl_framebuffer_texture2d( + target, attachment, textarget, texture.0, level, self.state, + ) + } + + #[napi] + pub fn front_face(&self, mode: u32) { + canvas_c::canvas_native_webgl_front_face(mode, self.state) + } + + #[napi] + pub fn generate_mipmap(&self, target: u32) { + canvas_c::canvas_native_webgl_generate_mipmap(target, self.state); + } + + + #[napi] + pub fn get_active_attrib(&self, env: Env, program: ClassInstance, index: u32) -> Result> { + WebGLActiveInfo( + canvas_c::canvas_native_webgl_get_active_attrib( + program.0, index, self.state, + ) + ).into_instance(env) + } + + #[napi] + pub fn get_active_uniform(&self, env: Env, program: ClassInstance, index: u32) -> Result> { + WebGLActiveInfo( + canvas_c::canvas_native_webgl_get_active_uniform( + program.0, index, self.state, + ) + ).into_instance(env) + } + + #[napi] + pub fn get_attached_shaders(&self, env: Env, program: ClassInstance) -> Vec> { + let state = unsafe { &mut *self.state }; + let shaders = canvas_webgl::webgl::canvas_native_webgl_get_attached_shaders(program.0, state.get_inner_mut()); + shaders.into_iter() + .map(|shader| { + WebGLShader(shader).into_instance(env).unwrap() + }).collect::>() + } + + #[napi] + pub fn get_attrib_location(&self, program: ClassInstance, name: JsString) -> Result { + let name = name.into_utf8()?; + let name = name.as_str()?; + let state = unsafe { &mut *self.state }; + Ok(canvas_webgl::webgl::canvas_native_webgl_get_attrib_location(program.0, name, state.get_inner_mut())) + } + + #[napi] + pub fn get_buffer_parameter(&self, target: u32, pname: u32) -> i32 { + canvas_c::canvas_native_webgl_get_buffer_parameter(target, pname, self.state) + } + + #[napi] + pub fn get_context_attributes(&self) -> context_attributes::ContextAttributes { + let attributes = canvas_c::canvas_native_webgl_get_context_attributes(self.state); + let ret = context_attributes::ContextAttributes::from_c(attributes); + canvas_c::canvas_native_context_attributes_destroy(attributes); + ret + } + + #[napi] + pub fn get_error(&self) -> u32 { + canvas_c::canvas_native_webgl_get_error(self.state) + } + + #[napi] + pub fn get_extension(&self, env: Env, name: JsString) -> Result { + let name = name.into_utf8()?; + let name = name.as_str()?; + + if name == "EXT_disjoint_timer_query_webgl2" { + return env.get_null().map(|null| null.into_unknown()); + } + let state = unsafe { &mut *self.state }; + + let ext = canvas_webgl::webgl::canvas_native_webgl_get_extension( + name.as_ref(), + state.get_inner_mut(), + ); + + + match ext { + None => { + env.get_null().map(|null| null.into_unknown()) + } + Some(ext) => { + let ext = Box::into_raw(Box::new(WebGLExtension::new(Some(ext)))); + + match name { + "ANGLE_instanced_arrays" => { + let ret = canvas_c::canvas_native_webgl_context_extension_to_angle_instanced_arrays(ext); + ANGLE_instanced_arrays(ret) + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_blend_minmax" => { + if ext.is_null() { + return env.get_null().map(|null| null.into_unknown()); + } + canvas_c::canvas_native_webgl_extension_destroy(ext); + EXT_blend_minmax + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_color_buffer_half_float" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + EXT_color_buffer_half_float + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_disjoint_timer_query" => { + let ext = canvas_c::canvas_native_webgl_context_extension_to_ext_disjoint_timer_query(ext); + EXT_disjoint_timer_query(ext) + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_sRGB" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + EXT_sRGB + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_shader_texture_lod" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + EXT_shader_texture_lod + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "EXT_texture_filter_anisotropic" => { + EXT_texture_filter_anisotropic + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_element_index_uint" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_element_index_uint + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_standard_derivatives" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_standard_derivatives + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_texture_float" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_texture_float + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_texture_float_linear" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_texture_float_linear + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_texture_half_floatr" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_texture_half_float + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_texture_half_float_linear" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + OES_texture_half_float_linear + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_vertex_array_object" => { + let ext = canvas_c::canvas_native_webgl_context_extension_to_oes_vertex_array_object(ext); + OES_vertex_array_object(ext) + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_color_buffer_float" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_color_buffer_float + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_compressed_texture_atc" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_compressed_texture_atc + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_compressed_texture_etc" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_compressed_texture_etc + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_compressed_texture_etc1" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_compressed_texture_etc1 + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_compressed_texture_pvrtc" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_compressed_texture_pvrtc + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_compressed_texture_s3tc" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_compressed_texture_s3tc + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_lose_context" => { + let ext = canvas_c::canvas_native_webgl_context_extension_to_lose_context(ext); + WEBGL_lose_context(ext) + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_depth_texture" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + WEBGL_depth_texture + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "WEBGL_draw_buffers" => { + let ext = canvas_c::canvas_native_webgl_context_extension_to_draw_buffers(ext); + WEBGL_draw_buffers(ext) + .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + "OES_fbo_render_mipmap" => { + canvas_c::canvas_native_webgl_extension_destroy(ext); + + OES_fbo_render_mipmap.into_instance(env).map(|ext| ext.as_object(env).into_unknown()) + } + _ => env.get_null().map(|null| null.into_unknown()), + } + } + } + } + + #[napi] + pub fn get_framebuffer_attachment_parameter(&self, env: Env, target: u32, attachment: u32, pname: u32) -> Result { + let mut state = unsafe { &mut *self.state }; + let ret = canvas_webgl::webgl::canvas_native_webgl_get_framebuffer_attachment_parameter( + target, + attachment, + pname, + state.get_inner_mut(), + ); + + + if ret.get_is_renderbuffer() { + return WebGLRenderbuffer(ret.get_value() as _) + .into_instance(env).map(|v| v.as_object(env).into_unknown()); + } else if ret.get_is_texture() { + return WebGLTexture(ret.get_value() as _) + .into_instance(env).map(|v| v.as_object(env).into_unknown()) + } + + env.create_int32(ret.get_value() as _).map(|v| v.into_unknown()) + } + + + #[napi] + pub fn get_program_info_log(&self, program: ClassInstance) -> String { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl::canvas_native_webgl_get_program_info_log(program.0, state.get_inner_mut()) + } + + #[napi] + pub fn get_program_parameter(&self, env: Env, program: ClassInstance, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl_get_program_parameter(program.0, pname, self.state); + if canvas_c::canvas_native_webgl_result_get_is_none(result) { + // todo + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + return env.get_null().map(|v| v.into_unknown()); + } + + + match pname { + gl_bindings::DELETE_STATUS | + gl_bindings::LINK_STATUS | + gl_bindings::VALIDATE_STATUS => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + _ => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_int32(ret).map(|v| v.into_unknown()) + } + } + } + + + #[napi] + pub fn get_renderbuffer_parameter(&self, target: u32, pname: u32) -> i32 { + canvas_c::canvas_native_webgl_get_renderbuffer_parameter(target, pname, self.state) + } + + #[napi] + pub fn get_shader_info_log(&self, shader: ClassInstance) -> String { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl::canvas_native_webgl_get_shader_info_log(shader.0, state.get_inner_mut()) + } + + #[napi] + pub fn get_shader_parameter(&self, env: Env, shader: ClassInstance, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl_get_shader_parameter(shader.0, pname, self.state); + match pname { + gl_bindings::DELETE_STATUS | gl_bindings::COMPILE_STATUS => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + _ => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_int32(ret).map(|v| v.into_unknown()) + } + } + } + + #[napi] + pub fn get_shader_precision_format(&self, env: Env, shader_type: u32, precision_type: u32) -> Result> { + let precision = canvas_c::canvas_native_webgl_get_shader_precision_format(shader_type, precision_type, self.state); + WebGLShaderPrecisionFormat(precision) + .into_instance(env) + } + + #[napi] + pub fn get_shader_source(&self, shader: ClassInstance) -> String { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl::canvas_native_webgl_get_shader_source(shader.0, state.get_inner_mut()) + } + + #[napi] + pub fn get_supported_extensions(&self) -> Vec { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl::canvas_native_webgl_get_supported_extensions(state.get_inner_mut()) + } + + #[napi] + pub fn get_tex_parameter(&self, target: u32, pname: u32) -> i32 { + canvas_c::canvas_native_webgl_get_tex_parameter(target, pname, self.state) + } + + #[napi] + pub fn get_uniform_location(&self, env: Env, program: ClassInstance, name: String) -> Result { + let state = unsafe { &mut *self.state }; + let location = canvas_webgl::webgl::canvas_native_webgl_get_uniform_location(program.0, name.as_str(), state.get_inner_mut()); + + if location == -1 { + return env.get_null().map(|v| v.into_unknown()); + } + + webgl_uniform_location::WebGLUniformLocation(location) + .into_instance(env) + .map(|v| v.as_object(env).into_unknown()) + } + + #[napi] + pub fn get_uniform(&self, env: Env, program: ClassInstance, location: ClassInstance) -> Result { + let result = canvas_c::canvas_native_webgl_get_uniform(program.0, location.0, self.state); + let type_ = canvas_c::canvas_native_webgl_result_get_type(result); + let uniform = match type_ { + WebGLResultType::Boolean => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + WebGLResultType::I32Array => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); + + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Int32, + len, + 0, + ).map(|v| v.into_unknown()) + } + WebGLResultType::U32Array => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_u32_array(result); + + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Uint32, + len, + 0, + ).map(|v| v.into_unknown()) + } + WebGLResultType::F32Array => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_f32_array(result); + + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Float32, + len, + 0, + ).map(|v| v.into_unknown()) + } + WebGLResultType::BooleanArray => { + let ret = canvas_c::canvas_native_webgl_result_get_bool_array(result); + let len = canvas_c::canvas_native_u8_buffer_get_length(ret); + let buf = canvas_c::canvas_native_u8_buffer_get_bytes(ret); + let buf = unsafe { std::slice::from_raw_parts(buf, len) }; + let mut array = env.create_array(len as u32)?; + + for i in 0..len { + array.set(i as u32, buf[i] == 1)?; + } + array.coerce_to_object().map(|v| v.into_unknown()) + } + WebGLResultType::U32 => { + let ret = canvas_c::canvas_native_webgl_result_get_u32(result); + env.create_uint32(ret).map(|v| v.into_unknown()) + } + WebGLResultType::I32 => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + env.create_int32(ret).map(|v| v.into_unknown()) + } + WebGLResultType::F32 => { + let ret = canvas_c::canvas_native_webgl_result_get_f32(result); + env.create_double(ret as f64).map(|v| v.into_unknown()) + } + WebGLResultType::String => unsafe { + let ret = canvas_c::canvas_native_webgl_result_get_string(result); + if ret.is_null() { + return Err(Error::from_status(Status::GenericFailure)); + } + let ret = CString::from_raw(ret as _); + match ret.into_string() { + Ok(s) => env.create_string_from_std(s), + Err(_) => Err(Error::from_status(Status::GenericFailure)), + }.map(|v| v.into_unknown()) + } + WebGLResultType::None => { + env.get_null().map(|v| v.into_unknown()) + } + }; + + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + + uniform + } + + #[napi] + pub fn get_vertex_attrib_offset(&self, index: u32, pname: u32) -> i64 { + canvas_c::canvas_native_webgl_get_vertex_attrib_offset(index, pname, self.state) as i64 + } + + #[napi] + pub fn get_vertex_attrib(&self, env: Env, index: u32, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl_get_vertex_attrib(index, pname, self.state); + + match pname { + gl_bindings::CURRENT_VERTEX_ATTRIB => unsafe { + let ret = canvas_c::canvas_native_webgl_result_get_f32_array(result); + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Float32, + len, + 0, + ).map(|v| v.into_unknown()) + } + gl_bindings::VERTEX_ATTRIB_ARRAY_ENABLED | gl_bindings::VERTEX_ATTRIB_ARRAY_NORMALIZED => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + _ => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + env.create_int32(ret).map(|v| v.into_unknown()) + } + } + } + + #[napi] + pub fn hint(&self, target: u32, mode: u32) { + canvas_c::canvas_native_webgl_hint(target, mode, self.state); + } + + + #[napi] + pub fn is_buffer(&self, buffer: ClassInstance) -> bool { + canvas_c::canvas_native_webgl_is_buffer(buffer.0, self.state) + } + + #[napi] + pub fn is_context_lost(&self) -> bool { + canvas_c::canvas_native_webgl_get_is_context_lost(self.state) + } + + #[napi] + pub fn is_enabled(&self, cap: u32) -> bool { + canvas_c::canvas_native_webgl_is_enabled(cap, self.state) + } + + #[napi] + pub fn is_framebuffer(&self, framebuffer: Option>) -> bool { + let framebuffer = match framebuffer { + None => 0, + Some(framebuffer) => framebuffer.0 + }; + canvas_c::canvas_native_webgl_is_framebuffer(framebuffer, self.state) + } + + #[napi] + pub fn is_program(&self, program: ClassInstance) -> bool { + canvas_c::canvas_native_webgl_is_program(program.0, self.state) + } + + #[napi] + pub fn is_renderbuffer(&self, renderbuffer: ClassInstance) -> bool { + canvas_c::canvas_native_webgl_is_renderbuffer(renderbuffer.0, self.state) + } + + #[napi] + pub fn is_shader(&self, shader: ClassInstance) -> bool { + canvas_c::canvas_native_webgl_is_shader(shader.0, self.state) + } + + #[napi] + pub fn is_texture(&self, texture: ClassInstance) -> bool { + canvas_c::canvas_native_webgl_is_texture(texture.0, self.state) + } + + #[napi] + pub fn line_width(&self, width: f64) { + canvas_c::canvas_native_webgl_line_width(width as f32, self.state); + } + + #[napi] + pub fn link_program(&self, program: ClassInstance) { + canvas_c::canvas_native_webgl_link_program(program.0, self.state) + } + + #[napi] + pub fn pixel_storei(&self, pname: u32, param: Either) { + match param { + Either::A(param) => { + let param = if param { 1 } else { 0 }; + match pname { + UNPACK_FLIP_Y_WEBGL | UNPACK_PREMULTIPLY_ALPHA_WEBGL => { + canvas_c::canvas_native_webgl_pixel_storei(pname, param, self.state) + } + _ => {} + } + } + Either::B(param) => { + match pname { + UNPACK_COLORSPACE_CONVERSION_WEBGL => { + canvas_c::canvas_native_webgl_pixel_storei(pname, 0x9244, self.state) + } + _ => { + canvas_c::canvas_native_webgl_pixel_storei(pname, param, self.state) + } + } + } + } + } + + + #[napi] + pub fn polygon_offset(&self, factor: f64, units: f64) { + canvas_c::canvas_native_webgl_polygon_offset(factor as f32, units as f32, self.state) + } + + #[napi( + ts_args_type = "x: number, y: number, width: number, height: number, format: number, type: number, pixels: ArrayBuffer | ArrayBufferView" + )] + pub fn read_pixels(&self, x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, mut pixels: Buffer) { + // todo + canvas_c::canvas_native_webgl_read_pixels_u8( + x, y, width, height, format, type_, pixels.as_mut_ptr(), pixels.len(), self.state, + ) + } + + #[napi] + pub fn renderbuffer_storage(&self, target: u32, internal_format: u32, width: i32, height: i32) { + let mut internal_format = internal_format; + if (internal_format == gl_bindings::DEPTH_STENCIL) { + // DEPTH24_STENCIL8 = 35056 + // DEPTH24_STENCIL8_OES = 0x88F0 + internal_format = 0x88f0; + } + canvas_c::canvas_native_webgl_renderbuffer_storage(target, internal_format, width, height, self.state) + } + + #[napi] + pub fn sample_coverage(&self, value: f64, invert: bool) { + canvas_c::canvas_native_webgl_sample_coverage(value as f32, invert, self.state); + } + + #[napi] + pub fn scissor(&self, x: i32, y: i32, width: i32, height: i32) { + canvas_c::canvas_native_webgl_scissor(x, y, width, height, self.state) + } + + #[napi] + pub fn shader_source(&self, shader: ClassInstance, source: String) { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl::canvas_native_webgl_shader_source(shader.0, source.as_str(), state.get_inner_mut()); + } + + #[napi(ts_args_type = "face:number, func: number, ref: number, mask: number")] + pub fn stencil_func_separate(&self, face: u32, func: u32, ref_: i32, mask: u32) { + canvas_c::canvas_native_webgl_stencil_func_separate(face, func, ref_, mask, self.state) + } + + #[napi(ts_args_type = "func: number, ref: number, mask: number")] + pub fn stencil_func(&self, func: u32, ref_: i32, mask: u32) { + canvas_c::canvas_native_webgl_stencil_func(func, ref_, mask, self.state) + } + + #[napi] + pub fn stencil_mask_separate(&self, face: u32, mask: u32) { + canvas_c::canvas_native_webgl_stencil_mask_separate(face, mask, self.state); + } + + #[napi] + pub fn stencil_mask(&self, mask: u32) { + canvas_c::canvas_native_webgl_stencil_mask(mask, self.state); + } + + #[napi] + pub fn stencil_op_separate(&self, face: u32, fail: u32, zfail: u32, zpass: u32) { + canvas_c::canvas_native_webgl_stencil_op_separate(face, fail, zfail, zpass, self.state); + } + + #[napi] + pub fn stencil_op(&self, fail: u32, zfail: u32, zpass: u32) { + canvas_c::canvas_native_webgl_stencil_op(fail, zfail, zpass, self.state); + } + + #[napi] + pub fn tex_image_2D(&self, target: i32, level: i32, internalformat: i32, width_or_format: i32, height_or_type: i32, border_or_pixels: Either4, ClassInstance, ClassInstance>, format: Option, type_: Option, pixels: Option>, offset: Option) -> Result<()> { + match border_or_pixels { + Either4::A(border) => { + match (format, type_, pixels) { + (Some(format), Some(type_), Some(pixels)) => { + match pixels { + Either::A(buffer) => { + canvas_c::canvas_native_webgl_tex_image2d( + target, level, internalformat, width_or_format, height_or_type, border, format, type_, buffer.as_ptr(), buffer.len(), self.state, + ) + } + Either::B(offset) => { + canvas_c::canvas_native_webgl2_tex_image2d_offset( + target, level, internalformat, width_or_format as u32, height_or_type as u32, border, format, type_, offset as u64, self.state, + ) + } + } + } + (Some(format), Some(type_), None) => { + canvas_c::canvas_native_webgl_tex_image2d_none( + target, level, internalformat, width_or_format, height_or_type, border, format, type_, self.state, + ) + } + _ => {} + } + } + Either4::B(c2d) => { + canvas_c::canvas_native_webgl_tex_image2d_canvas2d( + target, level, internalformat, width_or_format, height_or_type, c2d.context, self.state, + ) + } + Either4::C(gl) => { + canvas_c::canvas_native_webgl_tex_image2d_webgl( + target, level, internalformat, width_or_format, height_or_type, gl.state, self.state, + ) + } + Either4::D(image) => { + canvas_c::canvas_native_webgl_tex_image2d_image_asset( + target, level, internalformat, width_or_format, height_or_type, Arc::as_ptr(&image.asset), self.state, + ) + } + } + Ok(()) + } + + + #[napi] + pub fn tex_parameterf(&self, target: u32, pname: u32, param: f64) { + canvas_c::canvas_native_webgl_tex_parameterf(target, pname, param as f32, self.state); + } + + #[napi] + pub fn tex_parameteri(&self, target: u32, pname: u32, param: i32) { + canvas_c::canvas_native_webgl_tex_parameteri(target, pname, param, self.state); + } + + + #[napi(js_name = "uniform1f")] + pub fn uniform1f(&self, location: ClassInstance, v0: f64) { + canvas_c::canvas_native_webgl_uniform1f(location.0, v0 as f32, self.state); + } + + + #[napi(js_name = "uniform1iv")] + pub fn uniform1iv(&self, location: ClassInstance, value: Either, Int32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl_uniform1iv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform1iv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform1fv")] + pub fn uniform1fv(&self, location: ClassInstance, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform1fv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform1fv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform1i")] + pub fn uniform1i(&self, location: ClassInstance, v0: i32) { + canvas_c::canvas_native_webgl_uniform1i(location.0, v0, self.state); + } + + #[napi(js_name = "uniform2f")] + pub fn uniform2f(&self, location: ClassInstance, v0: f64, v1: f64) { + canvas_c::canvas_native_webgl_uniform2f(location.0, v0 as f32, v1 as f32, self.state); + } + + #[napi(js_name = "uniform2iv")] + pub fn uniform2iv(&self, location: ClassInstance, value: Either, Int32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl_uniform2iv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform2iv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform2fv")] + pub fn uniform2fv(&self, location: ClassInstance, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform2fv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform2fv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform2i")] + pub fn uniform2i(&self, location: ClassInstance, v0: i32, v1: i32) { + canvas_c::canvas_native_webgl_uniform2i(location.0, v0, v1, self.state); + } + + #[napi(js_name = "uniform3f")] + pub fn uniform3f(&self, location: ClassInstance, v0: f64, v1: f64, v2: f64) { + canvas_c::canvas_native_webgl_uniform3f(location.0, v0 as f32, v1 as f32, v2 as f32, self.state); + } + + #[napi(js_name = "uniform3iv")] + pub fn uniform3iv(&self, location: ClassInstance, value: Either, Int32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl_uniform3iv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform3iv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform3fv")] + pub fn uniform3fv(&self, location: ClassInstance, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform3fv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform3fv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform3i")] + pub fn uniform3i(&self, location: ClassInstance, v0: i32, v1: i32, v2: i32) { + canvas_c::canvas_native_webgl_uniform3i(location.0, v0, v1, v2, self.state); + } + + #[napi(js_name = "uniform4f")] + pub fn uniform4f(&self, location: ClassInstance, v0: f64, v1: f64, v2: f64, v3: f64) { + canvas_c::canvas_native_webgl_uniform4f(location.0, v0 as f32, v1 as f32, v2 as f32, v3 as f32, self.state); + } + + #[napi(js_name = "uniform4iv")] + pub fn uniform4iv(&self, location: ClassInstance, value: Either, Int32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl_uniform4iv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform4iv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform4fv")] + pub fn uniform4fv(&self, location: ClassInstance, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform4fv(location.0, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform4fv(location.0, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniform4i")] + pub fn uniform4i(&self, location: ClassInstance, v0: i32, v1: i32, v2: i32, v3: i32) { + canvas_c::canvas_native_webgl_uniform4i(location.0, v0, v1, v2, v3, self.state); + } + + #[napi(js_name = "uniformMatrix2fv")] + pub fn uniform_matrix2fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform_matrix2fv(location.0, transpose, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform_matrix2fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniformMatrix3fv")] + pub fn uniform_matrix3fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform_matrix3fv(location.0, transpose, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform_matrix3fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "uniformMatrix4fv")] + pub fn uniform_matrix4fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_uniform_matrix4fv(location.0, transpose, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_uniform_matrix4fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi] + pub fn use_program(&self, program: Option>) { + let program = program.map(|p| p.0).unwrap_or(0); + canvas_c::canvas_native_webgl_use_program(program, self.state) + } + + #[napi] + pub fn validate_program(&self, program: ClassInstance) { + canvas_c::canvas_native_webgl_validate_program(program.0, self.state) + } + + #[napi(js_name = "vertexAttrib1f")] + pub fn vertex_attrib1f(&self, index: u32, v0: f64) { + canvas_c::canvas_native_webgl_vertex_attrib1f(index, v0 as f32, self.state); + } + + #[napi(js_name = "vertexAttrib1fv")] + pub fn vertex_attrib1fv(&self, index: u32, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_vertex_attrib1fv(index, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_vertex_attrib1fv(index, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + + #[napi(js_name = "vertexAttrib2f")] + pub fn vertex_attrib2f(&self, index: u32, v0: f64, v1: f64) { + canvas_c::canvas_native_webgl_vertex_attrib2f(index, v0 as f32, v1 as f32, self.state); + } + + #[napi(js_name = "vertexAttrib2fv")] + pub fn vertex_attrib2fv(&self, index: u32, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_vertex_attrib2fv(index, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_vertex_attrib2fv(index, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "vertexAttrib3f")] + pub fn vertex_attrib3f(&self, index: u32, v0: f64, v1: f64, v2: f64) { + canvas_c::canvas_native_webgl_vertex_attrib3f(index, v0 as f32, v1 as f32, v2 as f32, self.state); + } + + #[napi(js_name = "vertexAttrib3fv")] + pub fn vertex_attrib3fv(&self, index: u32, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_vertex_attrib3fv(index, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_vertex_attrib3fv(index, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi(js_name = "vertexAttrib4f")] + pub fn vertex_attrib4f(&self, index: u32, v0: f64, v1: f64, v2: f64, v3: f64) { + canvas_c::canvas_native_webgl_vertex_attrib4f(index, v0 as f32, v1 as f32, v2 as f32, v3 as f32, self.state); + } + + #[napi(js_name = "vertexAttrib4fv")] + pub fn vertex_attrib4fv(&self, index: u32, value: Either, Float32Array>) { + match value { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl_vertex_attrib4fv(index, array.as_ptr(), array.len(), self.state); + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl_vertex_attrib4fv(index, buffer.as_ptr(), buffer.len(), self.state); + } + } + } + + #[napi( + ts_args_type = "index: number, size: number, type: number, normalized: boolean, stride: number, offset: number" + )] + pub fn vertex_attrib_pointer(&self, index: u32, size: i32, type_: u32, normalized: bool, stride: i32, offset: i64) { + canvas_c::canvas_native_webgl_vertex_attrib_pointer( + index, size, type_, normalized, stride, offset as isize, self.state, + ) + } + + #[napi] + pub fn viewport(&self, x: i32, y: i32, width: i32, height: i32) { + canvas_c::canvas_native_webgl_viewport(x, y, width, height, self.state); + } + + + #[napi(js_name = "toDataURL")] + pub fn to_data_url(&self, format: Option, encoderOptions: Option) -> String { + let c_str = CString::new(format.unwrap_or("image/png".to_string())).unwrap(); + let quality = encoderOptions + .map(|v| v as f32) + .unwrap_or(0.92) + .try_into() + .unwrap_or(0.92); + let quality: u32 = (quality * 100.) as u32; + let ret = canvas_c::canvas_native_webgl_to_data_url(self.state, c_str.as_ptr(), quality); + unsafe { CString::from_raw(ret as _).to_string_lossy().to_string() } + } + } + }; +} diff --git a/napi/canvas-napi/src/gl/constants.rs b/napi/canvas-napi/src/gl/constants.rs new file mode 100644 index 000000000..651a46e29 --- /dev/null +++ b/napi/canvas-napi/src/gl/constants.rs @@ -0,0 +1,2905 @@ +#[macro_export] +macro_rules! impl_webgl_context_constants { + ($struct_name:ident) => { + #[napi] + impl $struct_name { + #[napi(getter, js_name = "DEPTH_BUFFER_BIT")] + pub fn DEPTH_BUFFER_BIT(&self) -> u32 { + 0x00000100 + } + + #[napi(getter, js_name = "STENCIL_BUFFER_BIT")] + pub fn STENCIL_BUFFER_BIT(&self) -> u32 { + 0x00000400 + } + + #[napi(getter, js_name = "COLOR_BUFFER_BIT")] + pub fn COLOR_BUFFER_BIT(&self) -> u32 { + 0x00004000 + } + + #[napi(getter, js_name = "POINTS")] + pub fn POINTS(&self) -> u32 { + 0x0000 + } + + #[napi(getter, js_name = "LINES")] + pub fn LINES(&self) -> u32 { + 0x0001 + } + + #[napi(getter, js_name = "LINE_LOOP")] + pub fn LINE_LOOP(&self) -> u32 { + 0x0002 + } + + #[napi(getter, js_name = "LINE_STRIP")] + pub fn LINE_STRIP(&self) -> u32 { + 0x0003 + } + + #[napi(getter, js_name = "TRIANGLES")] + pub fn TRIANGLES(&self) -> u32 { + 0x0004 + } + + #[napi(getter, js_name = "TRIANGLE_STRIP")] + pub fn TRIANGLE_STRIP(&self) -> u32 { + 0x0005 + } + + #[napi(getter, js_name = "TRIANGLE_FAN")] + pub fn TRIANGLE_FAN(&self) -> u32 { + 0x0006 + } + + #[napi(getter, js_name = "ZERO")] + pub fn ZERO(&self) -> u32 { + 0 + } + + #[napi(getter, js_name = "ONE")] + pub fn ONE(&self) -> u32 { + 1 + } + + #[napi(getter, js_name = "SRC_COLOR")] + pub fn SRC_COLOR(&self) -> u32 { + 0x0300 + } + + #[napi(getter, js_name = "ONE_MINUS_SRC_COLOR")] + pub fn ONE_MINUS_SRC_COLOR(&self) -> u32 { + 0x0301 + } + + #[napi(getter, js_name = "SRC_ALPHA")] + pub fn SRC_ALPHA(&self) -> u32 { + 0x0302 + } + + #[napi(getter, js_name = "ONE_MINUS_SRC_ALPHA")] + pub fn ONE_MINUS_SRC_ALPHA(&self) -> u32 { + 0x0303 + } + + #[napi(getter, js_name = "DST_ALPHA")] + pub fn DST_ALPHA(&self) -> u32 { + 0x0304 + } + + #[napi(getter, js_name = "ONE_MINUS_DST_ALPHA")] + pub fn ONE_MINUS_DST_ALPHA(&self) -> u32 { + 0x0305 + } + + #[napi(getter, js_name = "DST_COLOR")] + pub fn DST_COLOR(&self) -> u32 { + 0x0306 + } + + #[napi(getter, js_name = "ONE_MINUS_DST_COLOR")] + pub fn ONE_MINUS_DST_COLOR(&self) -> u32 { + 0x0307 + } + + #[napi(getter, js_name = "SRC_ALPHA_SATURATE")] + pub fn SRC_ALPHA_SATURATE(&self) -> u32 { + 0x0308 + } + + #[napi(getter, js_name = "CONSTANT_COLOR")] + pub fn CONSTANT_COLOR(&self) -> u32 { + 0x8001 + } + + #[napi(getter, js_name = "ONE_MINUS_CONSTANT_COLOR")] + pub fn ONE_MINUS_CONSTANT_COLOR(&self) -> u32 { + 0x8002 + } + + #[napi(getter, js_name = "CONSTANT_ALPHA")] + pub fn CONSTANT_ALPHA(&self) -> u32 { + 0x8003 + } + + #[napi(getter, js_name = "ONE_MINUS_CONSTANT_ALPHA")] + pub fn ONE_MINUS_CONSTANT_ALPHA(&self) -> u32 { + 0x8004 + } + + /* Blending equations */ + #[napi(getter, js_name = "FUNC_ADD")] + pub fn FUNC_ADD(&self) -> u32 { + 0x8006 + } + + #[napi(getter, js_name = "FUNC_SUBTRACT")] + pub fn FUNC_SUBTRACT(&self) -> u32 { + 0x800A + } + + #[napi(getter, js_name = "FUNC_REVERSE_SUBTRACT")] + pub fn FUNC_REVERSE_SUBTRACT(&self) -> u32 { + 0x800B + } + + #[napi(getter, js_name = "BLEND_EQUATION")] + pub fn BLEND_EQUATION(&self) -> u32 { + 0x8009 + } + + #[napi(getter, js_name = "BLEND_EQUATION_RGB")] + pub fn BLEND_EQUATION_RGB(&self) -> u32 { + 0x8009 + } + + #[napi(getter, js_name = "BLEND_EQUATION_ALPHA")] + pub fn BLEND_EQUATION_ALPHA(&self) -> u32 { + 0x883D + } + + #[napi(getter, js_name = "BLEND_DST_RGB")] + pub fn BLEND_DST_RGB(&self) -> u32 { + 0x80C8 + } + + #[napi(getter, js_name = "BLEND_SRC_RGB")] + pub fn BLEND_SRC_RGB(&self) -> u32 { + 0x80C9 + } + + #[napi(getter, js_name = "BLEND_DST_ALPHA")] + pub fn BLEND_DST_ALPHA(&self) -> u32 { + 0x80CA + } + + #[napi(getter, js_name = "BLEND_SRC_ALPHA")] + pub fn BLEND_SRC_ALPHA(&self) -> u32 { + 0x80CB + } + + #[napi(getter, js_name = "BLEND_COLOR")] + pub fn BLEND_COLOR(&self) -> u32 { + 0x8005 + } + + #[napi(getter, js_name = "ARRAY_BUFFER_BINDING")] + pub fn ARRAY_BUFFER_BINDING(&self) -> u32 { + 0x8894 + } + + #[napi(getter, js_name = "ELEMENT_ARRAY_BUFFER_BINDING")] + pub fn ELEMENT_ARRAY_BUFFER_BINDING(&self) -> u32 { + 0x8895 + } + + #[napi(getter, js_name = "LINE_WIDTH")] + pub fn LINE_WIDTH(&self) -> u32 { + 0x0B21 + } + + #[napi(getter, js_name = "ALIASED_POINT_SIZE_RANGE")] + pub fn ALIASED_POINT_SIZE_RANGE(&self) -> u32 { + 0x846D + } + + #[napi(getter, js_name = "ALIASED_LINE_WIDTH_RANGE")] + pub fn ALIASED_LINE_WIDTH_RANGE(&self) -> u32 { + 0x846E + } + + #[napi(getter, js_name = "CULL_FACE_MODE")] + pub fn CULL_FACE_MODE(&self) -> u32 { + 0x0B45 + } + + #[napi(getter, js_name = "FRONT_FACE")] + pub fn FRONT_FACE(&self) -> u32 { + 0x0B46 + } + + #[napi(getter, js_name = "DEPTH_RANGE")] + pub fn DEPTH_RANGE(&self) -> u32 { + 0x0B70 + } + + #[napi(getter, js_name = "DEPTH_WRITEMASK")] + pub fn DEPTH_WRITEMASK(&self) -> u32 { + 0x0B72 + } + + #[napi(getter, js_name = "DEPTH_CLEAR_VALUE")] + pub fn DEPTH_CLEAR_VALUE(&self) -> u32 { + 0x0B73 + } + + #[napi(getter, js_name = "DEPTH_FUNC")] + pub fn DEPTH_FUNC(&self) -> u32 { + 0x0B74 + } + + #[napi(getter, js_name = "STENCIL_CLEAR_VALUE")] + pub fn STENCIL_CLEAR_VALUE(&self) -> u32 { + 0x0B91 + } + + #[napi(getter, js_name = "STENCIL_FUNC")] + pub fn STENCIL_FUNC(&self) -> u32 { + 0x0B92 + } + + #[napi(getter, js_name = "STENCIL_FAIL")] + pub fn STENCIL_FAIL(&self) -> u32 { + 0x0B94 + } + + #[napi(getter, js_name = "STENCIL_PASS_DEPTH_FAIL")] + pub fn STENCIL_PASS_DEPTH_FAIL(&self) -> u32 { + 0x0B95 + } + + #[napi(getter, js_name = "STENCIL_PASS_DEPTH_PASS")] + pub fn STENCIL_PASS_DEPTH_PASS(&self) -> u32 { + 0x0B96 + } + + #[napi(getter, js_name = "STENCIL_REF")] + pub fn STENCIL_REF(&self) -> u32 { + 0x0B97 + } + + #[napi(getter, js_name = "STENCIL_VALUE_MASK")] + pub fn STENCIL_VALUE_MASK(&self) -> u32 { + 0x0B93 + } + + #[napi(getter, js_name = "STENCIL_WRITEMASK")] + pub fn STENCIL_WRITEMASK(&self) -> u32 { + 0x0B98 + } + + #[napi(getter, js_name = "STENCIL_BACK_FUNC")] + pub fn STENCIL_BACK_FUNC(&self) -> u32 { + 0x8800 + } + + #[napi(getter, js_name = "STENCIL_BACK_FAIL")] + pub fn STENCIL_BACK_FAIL(&self) -> u32 { + 0x8801 + } + + #[napi(getter, js_name = "STENCIL_BACK_PASS_DEPTH_FAIL")] + pub fn STENCIL_BACK_PASS_DEPTH_FAIL(&self) -> u32 { + 0x8802 + } + + #[napi(getter, js_name = "STENCIL_BACK_PASS_DEPTH_PASS")] + pub fn STENCIL_BACK_PASS_DEPTH_PASS(&self) -> u32 { + 0x8803 + } + + #[napi(getter, js_name = "STENCIL_BACK_REF")] + pub fn STENCIL_BACK_REF(&self) -> u32 { + 0x8CA3 + } + + #[napi(getter, js_name = "STENCIL_BACK_VALUE_MASK")] + pub fn STENCIL_BACK_VALUE_MASK(&self) -> u32 { + 0x8CA4 + } + + #[napi(getter, js_name = "STENCIL_BACK_WRITEMASK")] + pub fn STENCIL_BACK_WRITEMASK(&self) -> u32 { + 0x8CA5 + } + + #[napi(getter, js_name = "VIEWPORT")] + pub fn VIEWPORT(&self) -> u32 { + 0x0BA2 + } + + #[napi(getter, js_name = "SCISSOR_BOX")] + pub fn SCISSOR_BOX(&self) -> u32 { + 0x0C10 + } + + #[napi(getter, js_name = "COLOR_CLEAR_VALUE")] + pub fn COLOR_CLEAR_VALUE(&self) -> u32 { + 0x0C22 + } + + #[napi(getter, js_name = "COLOR_WRITEMASK")] + pub fn COLOR_WRITEMASK(&self) -> u32 { + 0x0C23 + } + + #[napi(getter, js_name = "UNPACK_ALIGNMENT")] + pub fn UNPACK_ALIGNMENT(&self) -> u32 { + 0x0CF5 + } + + #[napi(getter, js_name = "PACK_ALIGNMENT")] + pub fn PACK_ALIGNMENT(&self) -> u32 { + 0x0D05 + } + + #[napi(getter, js_name = "MAX_TEXTURE_SIZE")] + pub fn MAX_TEXTURE_SIZE(&self) -> u32 { + 0x0D33 + } + + #[napi(getter, js_name = "MAX_VIEWPORT_DIMS")] + pub fn MAX_VIEWPORT_DIMS(&self) -> u32 { + 0x0D3A + } + + #[napi(getter, js_name = "SUBPIXEL_BITS")] + pub fn SUBPIXEL_BITS(&self) -> u32 { + 0x0D50 + } + + #[napi(getter, js_name = "RED_BITS")] + pub fn RED_BITS(&self) -> u32 { + 0x0D52 + } + + #[napi(getter, js_name = "GREEN_BITS")] + pub fn GREEN_BITS(&self) -> u32 { + 0x0D53 + } + + #[napi(getter, js_name = "BLUE_BITS")] + pub fn BLUE_BITS(&self) -> u32 { + 0x0D54 + } + + #[napi(getter, js_name = "ALPHA_BITS")] + pub fn ALPHA_BITS(&self) -> u32 { + 0x0D55 + } + + #[napi(getter, js_name = "DEPTH_BITS")] + pub fn DEPTH_BITS(&self) -> u32 { + 0x0D56 + } + + #[napi(getter, js_name = "STENCIL_BITS")] + pub fn STENCIL_BITS(&self) -> u32 { + 0x0D57 + } + + #[napi(getter, js_name = "POLYGON_OFFSET_UNITS")] + pub fn POLYGON_OFFSET_UNITS(&self) -> u32 { + 0x2A00 + } + + #[napi(getter, js_name = "POLYGON_OFFSET_FACTOR")] + pub fn POLYGON_OFFSET_FACTOR(&self) -> u32 { + 0x8038 + } + + #[napi(getter, js_name = "TEXTURE_BINDING_2D")] + pub fn TEXTURE_BINDING_2D(&self) -> u32 { + 0x8069 + } + + #[napi(getter, js_name = "SAMPLE_BUFFERS")] + pub fn SAMPLE_BUFFERS(&self) -> u32 { + 0x80A8 + } + + #[napi(getter, js_name = "SAMPLES")] + pub fn SAMPLES(&self) -> u32 { + 0x80A9 + } + + #[napi(getter, js_name = "SAMPLE_COVERAGE_VALUE")] + pub fn SAMPLE_COVERAGE_VALUE(&self) -> u32 { + 0x80AA + } + + #[napi(getter, js_name = "SAMPLE_COVERAGE_INVERT")] + pub fn SAMPLE_COVERAGE_INVERT(&self) -> u32 { + 0x80AB + } + + #[napi(getter, js_name = "COMPRESSED_TEXTURE_FORMATS")] + pub fn COMPRESSED_TEXTURE_FORMATS(&self) -> u32 { + 0x86A3 + } + + #[napi(getter, js_name = "VENDOR")] + pub fn VENDOR(&self) -> u32 { + 0x1F00 + } + + #[napi(getter, js_name = "RENDERER")] + pub fn RENDERER(&self) -> u32 { + 0x1F01 + } + + #[napi(getter, js_name = "VERSION")] + pub fn VERSION(&self) -> u32 { + 0x1F02 + } + + #[napi(getter, js_name = "IMPLEMENTATION_COLOR_READ_TYPE")] + pub fn IMPLEMENTATION_COLOR_READ_TYPE(&self) -> u32 { + 0x8B9A + } + + #[napi(getter, js_name = "IMPLEMENTATION_COLOR_READ_FORMAT")] + pub fn IMPLEMENTATION_COLOR_READ_FORMAT(&self) -> u32 { + 0x8B9B + } + + #[napi(getter, js_name = "BROWSER_DEFAULT_WEBGL")] + pub fn BROWSER_DEFAULT_WEBGL(&self) -> u32 { + 0x9244 + } + + #[napi(getter, js_name = "STATIC_DRAW")] + pub fn STATIC_DRAW(&self) -> u32 { + 0x88E4 + } + + #[napi(getter, js_name = "STREAM_DRAW")] + pub fn STREAM_DRAW(&self) -> u32 { + 0x88E0 + } + + #[napi(getter, js_name = "DYNAMIC_DRAW")] + pub fn DYNAMIC_DRAW(&self) -> u32 { + 0x88E8 + } + + #[napi(getter, js_name = "ARRAY_BUFFER")] + pub fn ARRAY_BUFFER(&self) -> u32 { + 0x8892 + } + + #[napi(getter, js_name = "ELEMENT_ARRAY_BUFFER")] + pub fn ELEMENT_ARRAY_BUFFER(&self) -> u32 { + 0x8893 + } + + #[napi(getter, js_name = "BUFFER_SIZE")] + pub fn BUFFER_SIZE(&self) -> u32 { + 0x8764 + } + + #[napi(getter, js_name = "BUFFER_USAGE")] + pub fn BUFFER_USAGE(&self) -> u32 { + 0x8765 + } + + #[napi(getter, js_name = "CURRENT_VERTEX_ATTRIB")] + pub fn CURRENT_VERTEX_ATTRIB(&self) -> u32 { + 0x8626 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_ENABLED")] + pub fn VERTEX_ATTRIB_ARRAY_ENABLED(&self) -> u32 { + 0x8622 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_SIZE")] + pub fn VERTEX_ATTRIB_ARRAY_SIZE(&self) -> u32 { + 0x8623 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_STRIDE")] + pub fn VERTEX_ATTRIB_ARRAY_STRIDE(&self) -> u32 { + 0x8624 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_TYPE")] + pub fn VERTEX_ATTRIB_ARRAY_TYPE(&self) -> u32 { + 0x8625 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_NORMALIZED")] + pub fn VERTEX_ATTRIB_ARRAY_NORMALIZED(&self) -> u32 { + 0x886A + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_POINTER")] + pub fn VERTEX_ATTRIB_ARRAY_POINTER(&self) -> u32 { + 0x8645 + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")] + pub fn VERTEX_ATTRIB_ARRAY_BUFFER_BINDING(&self) -> u32 { + 0x889F + } + + #[napi(getter, js_name = "CULL_FACE")] + pub fn CULL_FACE(&self) -> u32 { + 0x0B44 + } + + #[napi(getter, js_name = "FRONT")] + pub fn FRONT(&self) -> u32 { + 0x0404 + } + + #[napi(getter, js_name = "BACK")] + pub fn BACK(&self) -> u32 { + 0x0405 + } + + #[napi(getter, js_name = "FRONT_AND_BACK")] + pub fn FRONT_AND_BACK(&self) -> u32 { + 0x0408 + } + + #[napi(getter, js_name = "BLEND")] + pub fn BLEND(&self) -> u32 { + 0x0BE2 + } + + #[napi(getter, js_name = "DEPTH_TEST")] + pub fn DEPTH_TEST(&self) -> u32 { + 0x0B71 + } + + #[napi(getter, js_name = "DITHER")] + pub fn DITHER(&self) -> u32 { + 0x0BD0 + } + + #[napi(getter, js_name = "POLYGON_OFFSET_FILL")] + pub fn POLYGON_OFFSET_FILL(&self) -> u32 { + 0x8037 + } + + #[napi(getter, js_name = "SAMPLE_ALPHA_TO_COVERAGE")] + pub fn SAMPLE_ALPHA_TO_COVERAGE(&self) -> u32 { + 0x809E + } + + #[napi(getter, js_name = "SAMPLE_COVERAGE")] + pub fn SAMPLE_COVERAGE(&self) -> u32 { + 0x80A0 + } + + #[napi(getter, js_name = "SCISSOR_TEST")] + pub fn SCISSOR_TEST(&self) -> u32 { + 0x0C11 + } + + #[napi(getter, js_name = "STENCIL_TEST")] + pub fn STENCIL_TEST(&self) -> u32 { + 0x0B90 + } + + /* Errors */ + #[napi(getter, js_name = "NO_ERROR")] + pub fn NO_ERROR(&self) -> u32 { + 0 + } + + #[napi(getter, js_name = "INVALID_ENUM")] + pub fn INVALID_ENUM(&self) -> u32 { + 0x0500 + } + + #[napi(getter, js_name = "INVALID_VALUE")] + pub fn INVALID_VALUE(&self) -> u32 { + 0x0501 + } + + #[napi(getter, js_name = "INVALID_OPERATION")] + pub fn INVALID_OPERATION(&self) -> u32 { + 0x0502 + } + + #[napi(getter, js_name = "OUT_OF_MEMORY")] + pub fn OUT_OF_MEMORY(&self) -> u32 { + 0x0505 + } + + #[napi(getter, js_name = "CONTEXT_LOST_WEBGL")] + pub fn CONTEXT_LOST_WEBGL(&self) -> u32 { + 0x9242 + } + + #[napi(getter, js_name = "CW")] + pub fn CW(&self) -> u32 { + 0x0900 + } + + #[napi(getter, js_name = "CCW")] + pub fn CCW(&self) -> u32 { + 0x0901 + } + + #[napi(getter, js_name = "DONT_CARE")] + pub fn DONT_CARE(&self) -> u32 { + 0x1100 + } + + #[napi(getter, js_name = "FASTEST")] + pub fn FASTEST(&self) -> u32 { + 0x1101 + } + + #[napi(getter, js_name = "NICEST")] + pub fn NICEST(&self) -> u32 { + 0x1102 + } + + #[napi(getter, js_name = "GENERATE_MIPMAP_HINT")] + pub fn GENERATE_MIPMAP_HINT(&self) -> u32 { + 0x8192 + } + + #[napi(getter, js_name = "BYTE")] + pub fn BYTE(&self) -> u32 { + 0x1400 + } + + #[napi(getter, js_name = "UNSIGNED_BYTE")] + pub fn UNSIGNED_BYTE(&self) -> u32 { + 0x1401 + } + + #[napi(getter, js_name = "SHORT")] + pub fn SHORT(&self) -> u32 { + 0x1402 + } + + #[napi(getter, js_name = "UNSIGNED_SHORT")] + pub fn UNSIGNED_SHORT(&self) -> u32 { + 0x1403 + } + + #[napi(getter, js_name = "INT")] + pub fn INT(&self) -> u32 { + 0x1404 + } + + #[napi(getter, js_name = "UNSIGNED_INT")] + pub fn UNSIGNED_INT(&self) -> u32 { + 0x1405 + } + + #[napi(getter, js_name = "FLOAT")] + pub fn FLOAT(&self) -> u32 { + 0x1406 + } + + #[napi(getter, js_name = "DEPTH_COMPONENT")] + pub fn DEPTH_COMPONENT(&self) -> u32 { + 0x1902 + } + + #[napi(getter, js_name = "ALPHA")] + pub fn ALPHA(&self) -> u32 { + 0x1906 + } + + #[napi(getter, js_name = "RGB")] + pub fn RGB(&self) -> u32 { + 0x1907 + } + + /* Clearing buffers */ + + #[napi(getter, js_name = "RGBA")] + pub fn RGBA(&self) -> u32 { + 0x1908 + } + + #[napi(getter, js_name = "LUMINANCE")] + pub fn LUMINANCE(&self) -> u32 { + 0x1909 + } + + #[napi(getter, js_name = "LUMINANCE_ALPHA")] + pub fn LUMINANCE_ALPHA(&self) -> u32 { + 0x190A + } + + /* Clearing buffers */ + + /* Rendering primitives */ + + #[napi(getter, js_name = "UNSIGNED_SHORT_4_4_4_4")] + pub fn UNSIGNED_SHORT_4_4_4_4(&self) -> u32 { + 0x8033 + } + + #[napi(getter, js_name = "UNSIGNED_SHORT_5_5_5_1")] + pub fn UNSIGNED_SHORT_5_5_5_1(&self) -> u32 { + 0x8034 + } + + #[napi(getter, js_name = "UNSIGNED_SHORT_5_6_5")] + pub fn UNSIGNED_SHORT_5_6_5(&self) -> u32 { + 0x8363 + } + + #[napi(getter, js_name = "FRAGMENT_SHADER")] + pub fn FRAGMENT_SHADER(&self) -> u32 { + 0x8B30 + } + + #[napi(getter, js_name = "VERTEX_SHADER")] + pub fn VERTEX_SHADER(&self) -> u32 { + 0x8B31 + } + + #[napi(getter, js_name = "COMPILE_STATUS")] + pub fn COMPILE_STATUS(&self) -> u32 { + 0x8B81 + } + + #[napi(getter, js_name = "DELETE_STATUS")] + pub fn DELETE_STATUS(&self) -> u32 { + 0x8B80 + } + + /* Rendering primitives */ + + /* Blending modes */ + + #[napi(getter, js_name = "LINK_STATUS")] + pub fn LINK_STATUS(&self) -> u32 { + 0x8B82 + } + + #[napi(getter, js_name = "VALIDATE_STATUS")] + pub fn VALIDATE_STATUS(&self) -> u32 { + 0x8B83 + } + + #[napi(getter, js_name = "ATTACHED_SHADERS")] + pub fn ATTACHED_SHADERS(&self) -> u32 { + 0x8B85 + } + + #[napi(getter, js_name = "ACTIVE_ATTRIBUTES")] + pub fn ACTIVE_ATTRIBUTES(&self) -> u32 { + 0x8B89 + } + + #[napi(getter, js_name = "ACTIVE_UNIFORMS")] + pub fn ACTIVE_UNIFORMS(&self) -> u32 { + 0x8B86 + } + + #[napi(getter, js_name = "MAX_VERTEX_ATTRIBS")] + pub fn MAX_VERTEX_ATTRIBS(&self) -> u32 { + 0x8869 + } + + #[napi(getter, js_name = "MAX_VERTEX_UNIFORM_VECTORS")] + pub fn MAX_VERTEX_UNIFORM_VECTORS(&self) -> u32 { + 0x8DFB + } + + #[napi(getter, js_name = "MAX_VARYING_VECTORS")] + pub fn MAX_VARYING_VECTORS(&self) -> u32 { + 0x8DFC + } + + #[napi(getter, js_name = "MAX_COMBINED_TEXTURE_IMAGE_UNITS")] + pub fn MAX_COMBINED_TEXTURE_IMAGE_UNITS(&self) -> u32 { + 0x8B4D + } + + #[napi(getter, js_name = "MAX_VERTEX_TEXTURE_IMAGE_UNITS")] + pub fn MAX_VERTEX_TEXTURE_IMAGE_UNITS(&self) -> u32 { + 0x8B4C + } + + #[napi(getter, js_name = "MAX_TEXTURE_IMAGE_UNITS")] + pub fn MAX_TEXTURE_IMAGE_UNITS(&self) -> u32 { + 0x8872 + } + + #[napi(getter, js_name = "MAX_FRAGMENT_UNIFORM_VECTORS")] + pub fn MAX_FRAGMENT_UNIFORM_VECTORS(&self) -> u32 { + 0x8DFD + } + + #[napi(getter, js_name = "SHADER_TYPE")] + pub fn SHADER_TYPE(&self) -> u32 { + 0x8B4F + } + + #[napi(getter, js_name = "SHADING_LANGUAGE_VERSION")] + pub fn SHADING_LANGUAGE_VERSION(&self) -> u32 { + 0x8B8C + } + + #[napi(getter, js_name = "CURRENT_PROGRAM")] + pub fn CURRENT_PROGRAM(&self) -> u32 { + 0x8B8D + } + + /* Blending modes */ + + #[napi(getter, js_name = "NEVER")] + pub fn NEVER(&self) -> u32 { + 0x0200 + } + + #[napi(getter, js_name = "LESS")] + pub fn LESS(&self) -> u32 { + 0x0201 + } + + #[napi(getter, js_name = "EQUAL")] + pub fn EQUAL(&self) -> u32 { + 0x0202 + } + + /* Blending equations */ + + /* Getting GL parameter information */ + + #[napi(getter, js_name = "LEQUAL")] + pub fn LEQUAL(&self) -> u32 { + 0x0203 + } + + #[napi(getter, js_name = "GREATER")] + pub fn GREATER(&self) -> u32 { + 0x0204 + } + + #[napi(getter, js_name = "NOTEQUAL")] + pub fn NOTEQUAL(&self) -> u32 { + 0x0205 + } + + #[napi(getter, js_name = "GEQUAL")] + pub fn GEQUAL(&self) -> u32 { + 0x0206 + } + + #[napi(getter, js_name = "ALWAYS")] + pub fn ALWAYS(&self) -> u32 { + 0x0207 + } + + #[napi(getter, js_name = "KEEP")] + pub fn KEEP(&self) -> u32 { + 0x1E00 + } + + #[napi(getter, js_name = "REPLACE")] + pub fn REPLACE(&self) -> u32 { + 0x1E01 + } + + #[napi(getter, js_name = "INCR")] + pub fn INCR(&self) -> u32 { + 0x1E02 + } + + #[napi(getter, js_name = "DECR")] + pub fn DECR(&self) -> u32 { + 0x1E03 + } + + #[napi(getter, js_name = "INVERT")] + pub fn INVERT(&self) -> u32 { + 0x150A + } + + #[napi(getter, js_name = "INCR_WRAP")] + pub fn INCR_WRAP(&self) -> u32 { + 0x8507 + } + + #[napi(getter, js_name = "DECR_WRAP")] + pub fn DECR_WRAP(&self) -> u32 { + 0x8508 + } + + #[napi(getter, js_name = "NEAREST")] + pub fn NEAREST(&self) -> u32 { + 0x2600 + } + + #[napi(getter, js_name = "LINEAR")] + pub fn LINEAR(&self) -> u32 { + 0x2601 + } + + #[napi(getter, js_name = "NEAREST_MIPMAP_NEAREST")] + pub fn NEAREST_MIPMAP_NEAREST(&self) -> u32 { + 0x2700 + } + + #[napi(getter, js_name = "LINEAR_MIPMAP_NEAREST")] + pub fn LINEAR_MIPMAP_NEAREST(&self) -> u32 { + 0x2701 + } + + #[napi(getter, js_name = "NEAREST_MIPMAP_LINEAR")] + pub fn NEAREST_MIPMAP_LINEAR(&self) -> u32 { + 0x2702 + } + + #[napi(getter, js_name = "LINEAR_MIPMAP_LINEAR")] + pub fn LINEAR_MIPMAP_LINEAR(&self) -> u32 { + 0x2703 + } + + #[napi(getter, js_name = "TEXTURE_MAG_FILTER")] + pub fn TEXTURE_MAG_FILTER(&self) -> u32 { + 0x2800 + } + + #[napi(getter, js_name = "TEXTURE_MIN_FILTER")] + pub fn TEXTURE_MIN_FILTER(&self) -> u32 { + 0x2801 + } + + #[napi(getter, js_name = "TEXTURE_WRAP_S")] + pub fn TEXTURE_WRAP_S(&self) -> u32 { + 0x2802 + } + + #[napi(getter, js_name = "TEXTURE_WRAP_T")] + pub fn TEXTURE_WRAP_T(&self) -> u32 { + 0x2803 + } + + #[napi(getter, js_name = "TEXTURE_2D")] + pub fn TEXTURE_2D(&self) -> u32 { + 0x0DE1 + } + + #[napi(getter, js_name = "TEXTURE")] + pub fn TEXTURE(&self) -> u32 { + 0x1702 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP")] + pub fn TEXTURE_CUBE_MAP(&self) -> u32 { + 0x8513 + } + + #[napi(getter, js_name = "TEXTURE_BINDING_CUBE_MAP")] + pub fn TEXTURE_BINDING_CUBE_MAP(&self) -> u32 { + 0x8514 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_X")] + pub fn TEXTURE_CUBE_MAP_POSITIVE_X(&self) -> u32 { + 0x8515 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_X")] + pub fn TEXTURE_CUBE_MAP_NEGATIVE_X(&self) -> u32 { + 0x8516 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_Y")] + pub fn TEXTURE_CUBE_MAP_POSITIVE_Y(&self) -> u32 { + 0x8517 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_Y")] + pub fn TEXTURE_CUBE_MAP_NEGATIVE_Y(&self) -> u32 { + 0x8518 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_Z")] + pub fn TEXTURE_CUBE_MAP_POSITIVE_Z(&self) -> u32 { + 0x8519 + } + + #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_Z")] + pub fn TEXTURE_CUBE_MAP_NEGATIVE_Z(&self) -> u32 { + 0x851A + } + + #[napi(getter, js_name = "MAX_CUBE_MAP_TEXTURE_SIZE")] + pub fn MAX_CUBE_MAP_TEXTURE_SIZE(&self) -> u32 { + 0x851C + } + + #[napi(getter, js_name = "TEXTURE0")] + pub fn TEXTURE0(&self) -> u32 { + 0x84C0 + } + + #[napi(getter, js_name = "TEXTURE1")] + pub fn TEXTURE1(&self) -> u32 { + 0x84C1 + } + + #[napi(getter, js_name = "TEXTURE2")] + pub fn TEXTURE2(&self) -> u32 { + 0x84C2 + } + + #[napi(getter, js_name = "TEXTURE3")] + pub fn TEXTURE3(&self) -> u32 { + 0x84C3 + } + + #[napi(getter, js_name = "TEXTURE4")] + pub fn TEXTURE4(&self) -> u32 { + 0x84C4 + } + + #[napi(getter, js_name = "TEXTURE5")] + pub fn TEXTURE5(&self) -> u32 { + 0x84C5 + } + + #[napi(getter, js_name = "TEXTURE6")] + pub fn TEXTURE6(&self) -> u32 { + 0x84C6 + } + + #[napi(getter, js_name = "TEXTURE7")] + pub fn TEXTURE7(&self) -> u32 { + 0x84C7 + } + + #[napi(getter, js_name = "TEXTURE8")] + pub fn TEXTURE8(&self) -> u32 { + 0x84C8 + } + + #[napi(getter, js_name = "TEXTURE9")] + pub fn TEXTURE9(&self) -> u32 { + 0x84C9 + } + + #[napi(getter, js_name = "TEXTURE10")] + pub fn TEXTURE10(&self) -> u32 { + 0x84CA + } + + #[napi(getter, js_name = "TEXTURE11")] + pub fn TEXTURE11(&self) -> u32 { + 0x84CB + } + + #[napi(getter, js_name = "TEXTURE12")] + pub fn TEXTURE12(&self) -> u32 { + 0x84CC + } + + #[napi(getter, js_name = "TEXTURE13")] + pub fn TEXTURE13(&self) -> u32 { + 0x84CD + } + + #[napi(getter, js_name = "TEXTURE14")] + pub fn TEXTURE14(&self) -> u32 { + 0x84CE + } + + #[napi(getter, js_name = "TEXTURE15")] + pub fn TEXTURE15(&self) -> u32 { + 0x84CF + } + + #[napi(getter, js_name = "TEXTURE16")] + pub fn TEXTURE16(&self) -> u32 { + 0x84D0 + } + + #[napi(getter, js_name = "TEXTURE17")] + pub fn TEXTURE17(&self) -> u32 { + 0x84D1 + } + + #[napi(getter, js_name = "TEXTURE18")] + pub fn TEXTURE18(&self) -> u32 { + 0x84D2 + } + + #[napi(getter, js_name = "TEXTURE19")] + pub fn TEXTURE19(&self) -> u32 { + 0x84D3 + } + + #[napi(getter, js_name = "TEXTURE20")] + pub fn TEXTURE20(&self) -> u32 { + 0x84D4 + } + + #[napi(getter, js_name = "TEXTURE21")] + pub fn TEXTURE21(&self) -> u32 { + 0x84D5 + } + + #[napi(getter, js_name = "TEXTURE22")] + pub fn TEXTURE22(&self) -> u32 { + 0x84D6 + } + + #[napi(getter, js_name = "TEXTURE23")] + pub fn TEXTURE23(&self) -> u32 { + 0x84D7 + } + + #[napi(getter, js_name = "TEXTURE24")] + pub fn TEXTURE24(&self) -> u32 { + 0x84D8 + } + + #[napi(getter, js_name = "TEXTURE25")] + pub fn TEXTURE25(&self) -> u32 { + 0x84D9 + } + + #[napi(getter, js_name = "TEXTURE26")] + pub fn TEXTURE26(&self) -> u32 { + 0x84DA + } + + #[napi(getter, js_name = "TEXTURE27")] + pub fn TEXTURE27(&self) -> u32 { + 0x84DB + } + + #[napi(getter, js_name = "TEXTURE28")] + pub fn TEXTURE28(&self) -> u32 { + 0x84DC + } + + #[napi(getter, js_name = "TEXTURE29")] + pub fn TEXTURE29(&self) -> u32 { + 0x84DD + } + + /* Getting GL parameter information */ + + /* Buffers */ + + #[napi(getter, js_name = "TEXTURE30")] + pub fn TEXTURE30(&self) -> u32 { + 0x84DE + } + + #[napi(getter, js_name = "TEXTURE31")] + pub fn TEXTURE31(&self) -> u32 { + 0x84DF + } + + #[napi(getter, js_name = "ACTIVE_TEXTURE")] + pub fn ACTIVE_TEXTURE(&self) -> u32 { + 0x84E0 + } + + #[napi(getter, js_name = "REPEAT")] + pub fn REPEAT(&self) -> u32 { + 0x2901 + } + + #[napi(getter, js_name = "CLAMP_TO_EDGE")] + pub fn CLAMP_TO_EDGE(&self) -> u32 { + 0x812F + } + + #[napi(getter, js_name = "MIRRORED_REPEAT")] + pub fn MIRRORED_REPEAT(&self) -> u32 { + 0x8370 + } + + #[napi(getter, js_name = "FLOAT_VEC2")] + pub fn FLOAT_VEC2(&self) -> u32 { + 0x8B50 + } + + /* Buffers */ + + /* Vertex attributes */ + + #[napi(getter, js_name = "FLOAT_VEC3")] + pub fn FLOAT_VEC3(&self) -> u32 { + 0x8B51 + } + + #[napi(getter, js_name = "FLOAT_VEC4")] + pub fn FLOAT_VEC4(&self) -> u32 { + 0x8B52 + } + + #[napi(getter, js_name = "INT_VEC2")] + pub fn INT_VEC2(&self) -> u32 { + 0x8B53 + } + + #[napi(getter, js_name = "INT_VEC3")] + pub fn INT_VEC3(&self) -> u32 { + 0x8B54 + } + + #[napi(getter, js_name = "INT_VEC4")] + pub fn INT_VEC4(&self) -> u32 { + 0x8B55 + } + + #[napi(getter, js_name = "BOOL")] + pub fn BOOL(&self) -> u32 { + 0x8B56 + } + + #[napi(getter, js_name = "BOOL_VEC2")] + pub fn BOOL_VEC2(&self) -> u32 { + 0x8B57 + } + + #[napi(getter, js_name = "BOOL_VEC3")] + pub fn BOOL_VEC3(&self) -> u32 { + 0x8B58 + } + + /* Vertex attributes */ + + /* Culling */ + + #[napi(getter, js_name = "BOOL_VEC4")] + pub fn BOOL_VEC4(&self) -> u32 { + 0x8B59 + } + + #[napi(getter, js_name = "FLOAT_MAT2")] + pub fn FLOAT_MAT2(&self) -> u32 { + 0x8B5A + } + + #[napi(getter, js_name = "FLOAT_MAT3")] + pub fn FLOAT_MAT3(&self) -> u32 { + 0x8B5B + } + + #[napi(getter, js_name = "FLOAT_MAT4")] + pub fn FLOAT_MAT4(&self) -> u32 { + 0x8B5C + } + + /* Culling */ + + /* Enabling and disabling */ + + #[napi(getter, js_name = "SAMPLER_2D")] + pub fn SAMPLER_2D(&self) -> u32 { + 0x8B5E + } + + #[napi(getter, js_name = "SAMPLER_CUBE")] + pub fn SAMPLER_CUBE(&self) -> u32 { + 0x8B60 + } + + #[napi(getter, js_name = "LOW_FLOAT")] + pub fn LOW_FLOAT(&self) -> u32 { + 0x8DF0 + } + + #[napi(getter, js_name = "MEDIUM_FLOAT")] + pub fn MEDIUM_FLOAT(&self) -> u32 { + 0x8DF1 + } + + #[napi(getter, js_name = "HIGH_FLOAT")] + pub fn HIGH_FLOAT(&self) -> u32 { + 0x8DF2 + } + + #[napi(getter, js_name = "LOW_INT")] + pub fn LOW_INT(&self) -> u32 { + 0x8DF3 + } + + #[napi(getter, js_name = "MEDIUM_INT")] + pub fn MEDIUM_INT(&self) -> u32 { + 0x8DF4 + } + + #[napi(getter, js_name = "HIGH_INT")] + pub fn HIGH_INT(&self) -> u32 { + 0x8DF5 + } + + /* Enabling and disabling */ + + #[napi(getter, js_name = "FRAMEBUFFER")] + pub fn FRAMEBUFFER(&self) -> u32 { + 0x8D40 + } + + #[napi(getter, js_name = "RENDERBUFFER")] + pub fn RENDERBUFFER(&self) -> u32 { + 0x8D41 + } + + #[napi(getter, js_name = "RGBA4")] + pub fn RGBA4(&self) -> u32 { + 0x8056 + } + + #[napi(getter, js_name = "RGB5_A1")] + pub fn RGB5_A1(&self) -> u32 { + 0x8057 + } + + #[napi(getter, js_name = "RGB565")] + pub fn RGB565(&self) -> u32 { + 0x8D62 + } + + #[napi(getter, js_name = "DEPTH_COMPONENT16")] + pub fn DEPTH_COMPONENT16(&self) -> u32 { + 0x81A5 + } + + #[napi(getter, js_name = "STENCIL_INDEX8")] + pub fn STENCIL_INDEX8(&self) -> u32 { + 0x8D48 + } + + /* Errors */ + + /* Front face directions */ + + #[napi(getter, js_name = "DEPTH_STENCIL")] + pub fn DEPTH_STENCIL(&self) -> u32 { + 0x84F9 + } + + #[napi(getter, js_name = "RENDERBUFFER_WIDTH")] + pub fn RENDERBUFFER_WIDTH(&self) -> u32 { + 0x8D42 + } + + /* Front face directions */ + + /* Hints */ + + #[napi(getter, js_name = "RENDERBUFFER_HEIGHT")] + pub fn RENDERBUFFER_HEIGHT(&self) -> u32 { + 0x8D43 + } + + #[napi(getter, js_name = "RENDERBUFFER_INTERNAL_FORMAT")] + pub fn RENDERBUFFER_INTERNAL_FORMAT(&self) -> u32 { + 0x8D44 + } + + #[napi(getter, js_name = "RENDERBUFFER_RED_SIZE")] + pub fn RENDERBUFFER_RED_SIZE(&self) -> u32 { + 0x8D50 + } + + #[napi(getter, js_name = "RENDERBUFFER_GREEN_SIZE")] + pub fn RENDERBUFFER_GREEN_SIZE(&self) -> u32 { + 0x8D51 + } + + /* Hints */ + + /* Data types */ + + #[napi(getter, js_name = "RENDERBUFFER_BLUE_SIZE")] + pub fn RENDERBUFFER_BLUE_SIZE(&self) -> u32 { + 0x8D52 + } + + #[napi(getter, js_name = "RENDERBUFFER_ALPHA_SIZE")] + pub fn RENDERBUFFER_ALPHA_SIZE(&self) -> u32 { + 0x8D53 + } + + #[napi(getter, js_name = "RENDERBUFFER_DEPTH_SIZE")] + pub fn RENDERBUFFER_DEPTH_SIZE(&self) -> u32 { + 0x8D54 + } + + #[napi(getter, js_name = "RENDERBUFFER_STENCIL_SIZE")] + pub fn RENDERBUFFER_STENCIL_SIZE(&self) -> u32 { + 0x8D55 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE")] + pub fn FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE(&self) -> u32 { + 0x8CD0 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME")] + pub fn FRAMEBUFFER_ATTACHMENT_OBJECT_NAME(&self) -> u32 { + 0x8CD1 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL")] + pub fn FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL(&self) -> u32 { + 0x8CD2 + } + + /* Data types */ + + /* Pixel formats */ + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE")] + pub fn FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE(&self) -> u32 { + 0x8CD3 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT0")] + pub fn COLOR_ATTACHMENT0(&self) -> u32 { + 0x8CE0 + } + + #[napi(getter, js_name = "DEPTH_ATTACHMENT")] + pub fn DEPTH_ATTACHMENT(&self) -> u32 { + 0x8D00 + } + + #[napi(getter, js_name = "STENCIL_ATTACHMENT")] + pub fn STENCIL_ATTACHMENT(&self) -> u32 { + 0x8D20 + } + + #[napi(getter, js_name = "DEPTH_STENCIL_ATTACHMENT")] + pub fn DEPTH_STENCIL_ATTACHMENT(&self) -> u32 { + 0x821A + } + + #[napi(getter, js_name = "NONE")] + pub fn NONE(&self) -> u32 { + 0 + } + + /* Pixel formats */ + + /* Pixel types */ + + // #[napi(getter, js_name = "UNSIGNED_BYTE")] + // pub fn UNSIGNED_BYTE(&self) -> u32 { return UNSIGNED_BYTE} + + #[napi(getter, js_name = "FRAMEBUFFER_COMPLETE")] + pub fn FRAMEBUFFER_COMPLETE(&self) -> u32 { + 0x8CD5 + } + + #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT")] + pub fn FRAMEBUFFER_INCOMPLETE_ATTACHMENT(&self) -> u32 { + 0x8CD6 + } + + #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT")] + pub fn FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT(&self) -> u32 { + 0x8CD7 + } + + /* Pixel types */ + + /* Shaders */ + + #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS")] + pub fn FRAMEBUFFER_INCOMPLETE_DIMENSIONS(&self) -> u32 { + 0x8CD9 + } + + #[napi(getter, js_name = "FRAMEBUFFER_UNSUPPORTED")] + pub fn FRAMEBUFFER_UNSUPPORTED(&self) -> u32 { + 0x8CDD + } + + #[napi(getter, js_name = "FRAMEBUFFER_BINDING")] + pub fn FRAMEBUFFER_BINDING(&self) -> u32 { + 0x8CA6 + } + + #[napi(getter, js_name = "RENDERBUFFER_BINDING")] + pub fn RENDERBUFFER_BINDING(&self) -> u32 { + 0x8CA7 + } + + #[napi(getter, js_name = "MAX_RENDERBUFFER_SIZE")] + pub fn MAX_RENDERBUFFER_SIZE(&self) -> u32 { + 0x84E8 + } + + #[napi(getter, js_name = "INVALID_FRAMEBUFFER_OPERATION")] + pub fn INVALID_FRAMEBUFFER_OPERATION(&self) -> u32 { + 0x0506 + } + + #[napi(getter, js_name = "UNPACK_FLIP_Y_WEBGL")] + pub fn UNPACK_FLIP_Y_WEBGL(&self) -> u32 { + 0x9240 + } + + #[napi(getter, js_name = "UNPACK_PREMULTIPLY_ALPHA_WEBGL")] + pub fn UNPACK_PREMULTIPLY_ALPHA_WEBGL(&self) -> u32 { + 0x9241 + } + + #[napi(getter, js_name = "UNPACK_COLORSPACE_CONVERSION_WEBGL")] + pub fn UNPACK_COLORSPACE_CONVERSION_WEBGL(&self) -> u32 { + 0x9243 + } + } + }; +} + +#[macro_export] +macro_rules! impl_webgl2_context_constants { + ($struct_name:ident) => { + #[napi] + impl $struct_name { + /* Getting GL parameter information */ + #[napi(getter, js_name = "READ_BUFFER")] + pub fn READ_BUFFER(&self) -> u32 { + return 0x0c02; + } + + #[napi(getter, js_name = "UNPACK_ROW_LENGTH")] + pub fn UNPACK_ROW_LENGTH(&self) -> u32 { + return 0x0cf2; + } + + #[napi(getter, js_name = "UNPACK_SKIP_ROWS")] + pub fn UNPACK_SKIP_ROWS(&self) -> u32 { + return 0x0cf3; + } + + #[napi(getter, js_name = "UNPACK_SKIP_PIXELS")] + pub fn UNPACK_SKIP_PIXELS(&self) -> u32 { + return 0x0cf4; + } + + #[napi(getter, js_name = "PACK_ROW_LENGTH")] + pub fn PACK_ROW_LENGTH(&self) -> u32 { + return 0x0d02; + } + + #[napi(getter, js_name = "PACK_SKIP_ROWS")] + pub fn PACK_SKIP_ROWS(&self) -> u32 { + return 0x0d03; + } + + #[napi(getter, js_name = "PACK_SKIP_PIXELS")] + pub fn PACK_SKIP_PIXELS(&self) -> u32 { + return 0x0d04; + } + + #[napi(getter, js_name = "TEXTURE_BINDING_3D")] + pub fn TEXTURE_BINDING_3D(&self) -> u32 { + return 0x806a; + } + + #[napi(getter, js_name = "UNPACK_SKIP_IMAGES")] + pub fn UNPACK_SKIP_IMAGES(&self) -> u32 { + return 0x806d; + } + + #[napi(getter, js_name = "UNPACK_IMAGE_HEIGHT")] + pub fn UNPACK_IMAGE_HEIGHT(&self) -> u32 { + return 0x806e; + } + + #[napi(getter, js_name = "MAX_3D_TEXTURE_SIZE")] + pub fn MAX_3D_TEXTURE_SIZE(&self) -> u32 { + return 0x8073; + } + + #[napi(getter, js_name = "MAX_ELEMENTS_VERTICES")] + pub fn MAX_ELEMENTS_VERTICES(&self) -> u32 { + return 0x80e8; + } + + #[napi(getter, js_name = "MAX_ELEMENTS_INDICES")] + pub fn MAX_ELEMENTS_INDICES(&self) -> u32 { + return 0x80e9; + } + + #[napi(getter, js_name = "MAX_TEXTURE_LOD_BIAS")] + pub fn MAX_TEXTURE_LOD_BIAS(&self) -> u32 { + return 0x84fd; + } + + #[napi(getter, js_name = "MAX_FRAGMENT_UNIFORM_COMPONENTS")] + pub fn MAX_FRAGMENT_UNIFORM_COMPONENTS(&self) -> u32 { + return 0x8b49; + } + + #[napi(getter, js_name = "MAX_VERTEX_UNIFORM_COMPONENTS")] + pub fn MAX_VERTEX_UNIFORM_COMPONENTS(&self) -> u32 { + return 0x8b4a; + } + + #[napi(getter, js_name = "MAX_ARRAY_TEXTURE_LAYERS")] + pub fn MAX_ARRAY_TEXTURE_LAYERS(&self) -> u32 { + return 0x88ff; + } + + #[napi(getter, js_name = "MIN_PROGRAM_TEXEL_OFFSET")] + pub fn MIN_PROGRAM_TEXEL_OFFSET(&self) -> u32 { + return 0x8904; + } + + #[napi(getter, js_name = "MAX_PROGRAM_TEXEL_OFFSET")] + pub fn MAX_PROGRAM_TEXEL_OFFSET(&self) -> u32 { + return 0x8905; + } + + #[napi(getter, js_name = "MAX_VARYING_COMPONENTS")] + pub fn MAX_VARYING_COMPONENTS(&self) -> u32 { + return 0x8b4b; + } + + #[napi(getter, js_name = "FRAGMENT_SHADER_DERIVATIVE_HINT")] + pub fn FRAGMENT_SHADER_DERIVATIVE_HINT(&self) -> u32 { + return 0x8b8b; + } + + #[napi(getter, js_name = "RASTERIZER_DISCARD")] + pub fn RASTERIZER_DISCARD(&self) -> u32 { + return 0x8c89; + } + + #[napi(getter, js_name = "VERTEX_ARRAY_BINDING")] + pub fn VERTEX_ARRAY_BINDING(&self) -> u32 { + return 0x85b5; + } + + #[napi(getter, js_name = "MAX_VERTEX_OUTPUT_COMPONENTS")] + pub fn MAX_VERTEX_OUTPUT_COMPONENTS(&self) -> u32 { + return 0x9122; + } + + #[napi(getter, js_name = "MAX_FRAGMENT_INPUT_COMPONENTS")] + pub fn MAX_FRAGMENT_INPUT_COMPONENTS(&self) -> u32 { + return 0x9125; + } + + #[napi(getter, js_name = "MAX_SERVER_WAIT_TIMEOUT")] + pub fn MAX_SERVER_WAIT_TIMEOUT(&self) -> u32 { + return 0x9111; + } + + #[napi(getter, js_name = "MAX_ELEMENT_INDEX")] + pub fn MAX_ELEMENT_INDEX(&self) -> u32 { + return 0x8d6b; + } + + #[napi(getter, js_name = "RED")] + pub fn RED(&self) -> u32 { + return 0x1903; + } + + #[napi(getter, js_name = "RGB8")] + pub fn RGB8(&self) -> u32 { + return 0x8051; + } + + #[napi(getter, js_name = "RGBA8")] + pub fn RGBA8(&self) -> u32 { + return 0x8058; + } + + #[napi(getter, js_name = "RGB10_A2")] + pub fn RGB10_A2(&self) -> u32 { + return 0x8059; + } + + #[napi(getter, js_name = "TEXTURE_3D")] + pub fn TEXTURE_3D(&self) -> u32 { + return 0x806f; + } + + #[napi(getter, js_name = "TEXTURE_WRAP_R")] + pub fn TEXTURE_WRAP_R(&self) -> u32 { + return 0x8072; + } + + #[napi(getter, js_name = "TEXTURE_MIN_LOD")] + pub fn TEXTURE_MIN_LOD(&self) -> u32 { + return 0x813a; + } + + #[napi(getter, js_name = "TEXTURE_MAX_LOD")] + pub fn TEXTURE_MAX_LOD(&self) -> u32 { + return 0x813b; + } + + #[napi(getter, js_name = "TEXTURE_BASE_LEVEL")] + pub fn TEXTURE_BASE_LEVEL(&self) -> u32 { + return 0x813c; + } + + #[napi(getter, js_name = "TEXTURE_MAX_LEVEL")] + pub fn TEXTURE_MAX_LEVEL(&self) -> u32 { + return 0x813d; + } + + #[napi(getter, js_name = "TEXTURE_COMPARE_MODE")] + pub fn TEXTURE_COMPARE_MODE(&self) -> u32 { + return 0x884c; + } + + #[napi(getter, js_name = "TEXTURE_COMPARE_FUNC")] + pub fn TEXTURE_COMPARE_FUNC(&self) -> u32 { + return 0x884d; + } + + #[napi(getter, js_name = "SRGB")] + pub fn SRGB(&self) -> u32 { + return 0x8c40; + } + + #[napi(getter, js_name = "SRGB8")] + pub fn SRGB8(&self) -> u32 { + return 0x8c41; + } + + #[napi(getter, js_name = "SRGB8_ALPHA8")] + pub fn SRGB8_ALPHA8(&self) -> u32 { + return 0x8c43; + } + + #[napi(getter, js_name = "COMPARE_REF_TO_TEXTURE")] + pub fn COMPARE_REF_TO_TEXTURE(&self) -> u32 { + return 0x884e; + } + + #[napi(getter, js_name = "RGBA32F")] + pub fn RGBA32F(&self) -> u32 { + return 0x8814; + } + + #[napi(getter, js_name = "RGB32F")] + pub fn RGB32F(&self) -> u32 { + return 0x8815; + } + + #[napi(getter, js_name = "RGBA16F")] + pub fn RGBA16F(&self) -> u32 { + return 0x881a; + } + + #[napi(getter, js_name = "RGB16F")] + pub fn RGB16F(&self) -> u32 { + return 0x881b; + } + + #[napi(getter, js_name = "TEXTURE_2D_ARRAY")] + pub fn TEXTURE_2D_ARRAY(&self) -> u32 { + return 0x8c1a; + } + + #[napi(getter, js_name = "TEXTURE_BINDING_2D_ARRAY")] + pub fn TEXTURE_BINDING_2D_ARRAY(&self) -> u32 { + return 0x8c1d; + } + + #[napi(getter, js_name = "R11F_G11F_B10F")] + pub fn R11F_G11F_B10F(&self) -> u32 { + return 0x8c3a; + } + + #[napi(getter, js_name = "RGB9_E5")] + pub fn RGB9_E5(&self) -> u32 { + return 0x8c3d; + } + + #[napi(getter, js_name = "RGBA32UI")] + pub fn RGBA32UI(&self) -> u32 { + return 0x8d70; + } + + #[napi(getter, js_name = "RGB32UI")] + pub fn RGB32UI(&self) -> u32 { + return 0x8d71; + } + + #[napi(getter, js_name = "RGBA16UI")] + pub fn RGBA16UI(&self) -> u32 { + return 0x8d76; + } + + + /* Getting GL parameter information */ + + #[napi(getter, js_name = "RGB16UI")] + pub fn RGB16UI(&self) -> u32 { + return 0x8d77; + } + + #[napi(getter, js_name = "RGBA8UI")] + pub fn RGBA8UI(&self) -> u32 { + return 0x8d7c; + } + + #[napi(getter, js_name = "RGB8UI")] + pub fn RGB8UI(&self) -> u32 { + return 0x8d7d; + } + + #[napi(getter, js_name = "RGBA32I")] + pub fn RGBA32I(&self) -> u32 { + return 0x8d82; + } + + #[napi(getter, js_name = "RGB32I")] + pub fn RGB32I(&self) -> u32 { + return 0x8d83; + } + + #[napi(getter, js_name = "RGBA16I")] + pub fn RGBA16I(&self) -> u32 { + return 0x8d88; + } + + #[napi(getter, js_name = "RGB16I")] + pub fn RGB16I(&self) -> u32 { + return 0x8d89; + } + + #[napi(getter, js_name = "RGBA8I")] + pub fn RGBA8I(&self) -> u32 { + return 0x8d8e; + } + + #[napi(getter, js_name = "RGB8I")] + pub fn RGB8I(&self) -> u32 { + return 0x8d8f; + } + + #[napi(getter, js_name = "RED_INTEGER")] + pub fn RED_INTEGER(&self) -> u32 { + return 0x8d94; + } + + #[napi(getter, js_name = "RGB_INTEGER")] + pub fn RGB_INTEGER(&self) -> u32 { + return 0x8d98; + } + + #[napi(getter, js_name = "RGBA_INTEGER")] + pub fn RGBA_INTEGER(&self) -> u32 { + return 0x8d99; + } + + #[napi(getter, js_name = "R8")] + pub fn R8(&self) -> u32 { + return 0x8229; + } + + #[napi(getter, js_name = "RG8")] + pub fn RG8(&self) -> u32 { + return 0x822b; + } + + #[napi(getter, js_name = "R16F")] + pub fn R16F(&self) -> u32 { + return 0x822d; + } + + #[napi(getter, js_name = "R32F")] + pub fn R32F(&self) -> u32 { + return 0x822e; + } + + #[napi(getter, js_name = "RG16F")] + pub fn RG16F(&self) -> u32 { + return 0x822f; + } + + #[napi(getter, js_name = "RG32F")] + pub fn RG32F(&self) -> u32 { + return 0x8230; + } + + #[napi(getter, js_name = "R8I")] + pub fn R8I(&self) -> u32 { + return 0x8231; + } + + #[napi(getter, js_name = "R8UI")] + pub fn R8UI(&self) -> u32 { + return 0x8232; + } + + #[napi(getter, js_name = "R16I")] + pub fn R16I(&self) -> u32 { + return 0x8233; + } + + #[napi(getter, js_name = "R16UI")] + pub fn R16UI(&self) -> u32 { + return 0x8234; + } + + #[napi(getter, js_name = "R32I")] + pub fn R32I(&self) -> u32 { + return 0x8235; + } + + #[napi(getter, js_name = "R32UI")] + pub fn R32UI(&self) -> u32 { + return 0x8236; + } + + #[napi(getter, js_name = "RG8I")] + pub fn RG8I(&self) -> u32 { + return 0x8237; + } + + #[napi(getter, js_name = "RG8UI")] + pub fn RG8UI(&self) -> u32 { + return 0x8238; + } + + #[napi(getter, js_name = "RG16I")] + pub fn RG16I(&self) -> u32 { + return 0x8239; + } + + #[napi(getter, js_name = "RG16UI")] + pub fn RG16UI(&self) -> u32 { + return 0x823a; + } + + #[napi(getter, js_name = "RG32I")] + pub fn RG32I(&self) -> u32 { + return 0x823b; + } + + #[napi(getter, js_name = "RG32UI")] + pub fn RG32UI(&self) -> u32 { + return 0x823c; + } + + #[napi(getter, js_name = "R8_SNORM")] + pub fn R8_SNORM(&self) -> u32 { + return 0x8f94; + } + + #[napi(getter, js_name = "RG8_SNORM")] + pub fn RG8_SNORM(&self) -> u32 { + return 0x8f95; + } + + #[napi(getter, js_name = "RGB8_SNORM")] + pub fn RGB8_SNORM(&self) -> u32 { + return 0x8f96; + } + + #[napi(getter, js_name = "RGBA8_SNORM")] + pub fn RGBA8_SNORM(&self) -> u32 { + return 0x8f97; + } + + #[napi(getter, js_name = "RGB10_A2UI")] + pub fn RGB10_A2UI(&self) -> u32 { + return 0x906f; + } + + #[napi(getter, js_name = "TEXTURE_IMMUTABLE_FORMAT")] + pub fn TEXTURE_IMMUTABLE_FORMAT(&self) -> u32 { + return 0x912f; + } + + #[napi(getter, js_name = "TEXTURE_IMMUTABLE_LEVELS")] + pub fn TEXTURE_IMMUTABLE_LEVELS(&self) -> u32 { + return 0x82df; + } + + #[napi(getter, js_name = "UNSIGNED_INT_2_10_10_10_REV")] + pub fn UNSIGNED_INT_2_10_10_10_REV(&self) -> u32 { + return 0x8368; + } + + #[napi(getter, js_name = "UNSIGNED_INT_10F_11F_11F_REV")] + pub fn UNSIGNED_INT_10F_11F_11F_REV(&self) -> u32 { + return 0x8c3b; + } + + #[napi(getter, js_name = "UNSIGNED_INT_5_9_9_9_REV")] + pub fn UNSIGNED_INT_5_9_9_9_REV(&self) -> u32 { + return 0x8c3e; + } + + #[napi(getter, js_name = "FLOAT_32_UNSIGNED_INT_24_8_REV")] + pub fn FLOAT_32_UNSIGNED_INT_24_8_REV(&self) -> u32 { + return 0x8dad; + } + + #[napi(getter, js_name = "UNSIGNED_INT_24_8")] + pub fn UNSIGNED_INT_24_8(&self) -> u32 { + return 0x84fa; + } + + #[napi(getter, js_name = "HALF_FLOAT")] + pub fn HALF_FLOAT(&self) -> u32 { + return 0x140b; + } + + #[napi(getter, js_name = "RG")] + pub fn RG(&self) -> u32 { + return 0x8227; + } + + #[napi(getter, js_name = "RG_INTEGER")] + pub fn RG_INTEGER(&self) -> u32 { + return 0x8228; + } + + #[napi(getter, js_name = "INT_2_10_10_10_REV")] + pub fn INT_2_10_10_10_REV(&self) -> u32 { + return 0x8d9f; + } + + #[napi(getter, js_name = "QUERY_RESULT_AVAILABLE")] + pub fn QUERY_RESULT_AVAILABLE(&self) -> u32 { + return 0x8865; + } + + #[napi(getter, js_name = "QUERY_RESULT")] + pub fn QUERY_RESULT(&self) -> u32 { + return 0x8866; + } + + #[napi(getter, js_name = "CURRENT_QUERY")] + pub fn CURRENT_QUERY(&self) -> u32 { + return 0x8867; + } + + #[napi(getter, js_name = "ANY_SAMPLES_PASSED")] + pub fn ANY_SAMPLES_PASSED(&self) -> u32 { + return 0x8c2f; + } + + #[napi(getter, js_name = "ANY_SAMPLES_PASSED_CONSERVATIVE")] + pub fn ANY_SAMPLES_PASSED_CONSERVATIVE(&self) -> u32 { + return 0x8d6a; + } + + #[napi(getter, js_name = "MAX_DRAW_BUFFERS")] + pub fn MAX_DRAW_BUFFERS(&self) -> u32 { + return 0x8824; + } + + #[napi(getter, js_name = "DRAW_BUFFER0")] + pub fn DRAW_BUFFER0(&self) -> u32 { + return 0x8825; + } + + #[napi(getter, js_name = "DRAW_BUFFER1")] + pub fn DRAW_BUFFER1(&self) -> u32 { + return 0x8826; + } + + #[napi(getter, js_name = "DRAW_BUFFER2")] + pub fn DRAW_BUFFER2(&self) -> u32 { + return 0x8827; + } + + #[napi(getter, js_name = "DRAW_BUFFER3")] + pub fn DRAW_BUFFER3(&self) -> u32 { + return 0x8828; + } + + #[napi(getter, js_name = "DRAW_BUFFER4")] + pub fn DRAW_BUFFER4(&self) -> u32 { + return 0x8829; + } + + #[napi(getter, js_name = "DRAW_BUFFER5")] + pub fn DRAW_BUFFER5(&self) -> u32 { + return 0x882a; + } + + #[napi(getter, js_name = "DRAW_BUFFER6")] + pub fn DRAW_BUFFER6(&self) -> u32 { + return 0x882b; + } + + #[napi(getter, js_name = "DRAW_BUFFER7")] + pub fn DRAW_BUFFER7(&self) -> u32 { + return 0x882c; + } + + #[napi(getter, js_name = "DRAW_BUFFER8")] + pub fn DRAW_BUFFER8(&self) -> u32 { + return 0x882d; + } + + #[napi(getter, js_name = "DRAW_BUFFER9")] + pub fn DRAW_BUFFER9(&self) -> u32 { + return 0x882e; + } + + #[napi(getter, js_name = "DRAW_BUFFER10")] + pub fn DRAW_BUFFER10(&self) -> u32 { + return 0x882f; + } + + /* Textures */ + + #[napi(getter, js_name = "DRAW_BUFFER11")] + pub fn DRAW_BUFFER11(&self) -> u32 { + 0x8830 + } + + #[napi(getter, js_name = "DRAW_BUFFER12")] + pub fn DRAW_BUFFER12(&self) -> u32 { + 0x8831 + } + + #[napi(getter, js_name = "DRAW_BUFFER13")] + pub fn DRAW_BUFFER13(&self) -> u32 { + 0x8832 + } + + #[napi(getter, js_name = "DRAW_BUFFER14")] + pub fn DRAW_BUFFER14(&self) -> u32 { + 0x8833 + } + + #[napi(getter, js_name = "DRAW_BUFFER15")] + pub fn DRAW_BUFFER15(&self) -> u32 { + 0x8834 + } + + #[napi(getter, js_name = "MAX_COLOR_ATTACHMENTS")] + pub fn MAX_COLOR_ATTACHMENTS(&self) -> u32 { + 0x8cdf + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT1")] + pub fn COLOR_ATTACHMENT1(&self) -> u32 { + 0x8ce1 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT2")] + pub fn COLOR_ATTACHMENT2(&self) -> u32 { + 0x8ce2 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT3")] + pub fn COLOR_ATTACHMENT3(&self) -> u32 { + 0x8ce3 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT4")] + pub fn COLOR_ATTACHMENT4(&self) -> u32 { + 0x8ce4 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT5")] + pub fn COLOR_ATTACHMENT5(&self) -> u32 { + 0x8ce5 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT6")] + pub fn COLOR_ATTACHMENT6(&self) -> u32 { + 0x8ce6 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT7")] + pub fn COLOR_ATTACHMENT7(&self) -> u32 { + 0x8ce7 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT8")] + pub fn COLOR_ATTACHMENT8(&self) -> u32 { + 0x8ce8 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT9")] + pub fn COLOR_ATTACHMENT9(&self) -> u32 { + 0x8ce9 + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT10")] + pub fn COLOR_ATTACHMENT10(&self) -> u32 { + 0x8cea + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT11")] + pub fn COLOR_ATTACHMENT11(&self) -> u32 { + 0x8ceb + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT12")] + pub fn COLOR_ATTACHMENT12(&self) -> u32 { + 0x8cec + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT13")] + pub fn COLOR_ATTACHMENT13(&self) -> u32 { + 0x8ced + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT14")] + pub fn COLOR_ATTACHMENT14(&self) -> u32 { + 0x8cee + } + + #[napi(getter, js_name = "COLOR_ATTACHMENT15")] + pub fn COLOR_ATTACHMENT15(&self) -> u32 { + 0x8cef + } + + #[napi(getter, js_name = "SAMPLER_3D")] + pub fn SAMPLER_3D(&self) -> u32 { + 0x8b5f + } + + #[napi(getter, js_name = "SAMPLER_2D_SHADOW")] + pub fn SAMPLER_2D_SHADOW(&self) -> u32 { + 0x8b62 + } + + #[napi(getter, js_name = "SAMPLER_2D_ARRAY")] + pub fn SAMPLER_2D_ARRAY(&self) -> u32 { + 0x8dc1 + } + + #[napi(getter, js_name = "SAMPLER_2D_ARRAY_SHADOW")] + pub fn SAMPLER_2D_ARRAY_SHADOW(&self) -> u32 { + 0x8dc4 + } + + #[napi(getter, js_name = "SAMPLER_CUBE_SHADOW")] + pub fn SAMPLER_CUBE_SHADOW(&self) -> u32 { + 0x8dc5 + } + + #[napi(getter, js_name = "INT_SAMPLER_2D")] + pub fn INT_SAMPLER_2D(&self) -> u32 { + 0x8dca + } + + #[napi(getter, js_name = "INT_SAMPLER_3D")] + pub fn INT_SAMPLER_3D(&self) -> u32 { + 0x8dcb + } + + #[napi(getter, js_name = "INT_SAMPLER_CUBE")] + pub fn INT_SAMPLER_CUBE(&self) -> u32 { + 0x8dcc + } + + #[napi(getter, js_name = "INT_SAMPLER_2D_ARRAY")] + pub fn INT_SAMPLER_2D_ARRAY(&self) -> u32 { + 0x8dcf + } + + #[napi(getter, js_name = "UNSIGNED_INT_SAMPLER_2D")] + pub fn UNSIGNED_INT_SAMPLER_2D(&self) -> u32 { + 0x8dd2 + } + + #[napi(getter, js_name = "UNSIGNED_INT_SAMPLER_3D")] + pub fn UNSIGNED_INT_SAMPLER_3D(&self) -> u32 { + 0x8dd3 + } + + #[napi(getter, js_name = "UNSIGNED_INT_SAMPLER_CUBE")] + pub fn UNSIGNED_INT_SAMPLER_CUBE(&self) -> u32 { + 0x8dd4 + } + + #[napi(getter, js_name = "UNSIGNED_INT_SAMPLER_2D_ARRAY")] + pub fn UNSIGNED_INT_SAMPLER_2D_ARRAY(&self) -> u32 { + 0x8dd7 + } + + #[napi(getter, js_name = "MAX_SAMPLES")] + pub fn MAX_SAMPLES(&self) -> u32 { + 0x8d57 + } + + #[napi(getter, js_name = "SAMPLER_BINDING")] + pub fn SAMPLER_BINDING(&self) -> u32 { + 0x8919 + } + + #[napi(getter, js_name = "PIXEL_PACK_BUFFER")] + pub fn PIXEL_PACK_BUFFER(&self) -> u32 { + 0x88eb + } + + #[napi(getter, js_name = "PIXEL_UNPACK_BUFFER")] + pub fn PIXEL_UNPACK_BUFFER(&self) -> u32 { + 0x88ec + } + + #[napi(getter, js_name = "PIXEL_PACK_BUFFER_BINDING")] + pub fn PIXEL_PACK_BUFFER_BINDING(&self) -> u32 { + 0x88ed + } + + #[napi(getter, js_name = "PIXEL_UNPACK_BUFFER_BINDING")] + pub fn PIXEL_UNPACK_BUFFER_BINDING(&self) -> u32 { + 0x88ef + } + + #[napi(getter, js_name = "COPY_READ_BUFFER")] + pub fn COPY_READ_BUFFER(&self) -> u32 { + 0x8f36 + } + + #[napi(getter, js_name = "COPY_WRITE_BUFFER")] + pub fn COPY_WRITE_BUFFER(&self) -> u32 { + 0x8f37 + } + + #[napi(getter, js_name = "COPY_READ_BUFFER_BINDING")] + pub fn COPY_READ_BUFFER_BINDING(&self) -> u32 { + 0x8f36 + } + + #[napi(getter, js_name = "COPY_WRITE_BUFFER_BINDING")] + pub fn COPY_WRITE_BUFFER_BINDING(&self) -> u32 { + 0x8f37 + } + + #[napi(getter, js_name = "FLOAT_MAT2x3")] + pub fn FLOAT_MAT2x3(&self) -> u32 { + 0x8b65 + } + + #[napi(getter, js_name = "FLOAT_MAT2x4")] + pub fn FLOAT_MAT2x4(&self) -> u32 { + 0x8b66 + } + + #[napi(getter, js_name = "FLOAT_MAT3x2")] + pub fn FLOAT_MAT3x2(&self) -> u32 { + 0x8b67 + } + + #[napi(getter, js_name = "FLOAT_MAT3x4")] + pub fn FLOAT_MAT3x4(&self) -> u32 { + 0x8b68 + } + + #[napi(getter, js_name = "FLOAT_MAT4x2")] + pub fn FLOAT_MAT4x2(&self) -> u32 { + 0x8b69 + } + + #[napi(getter, js_name = "FLOAT_MAT4x3")] + pub fn FLOAT_MAT4x3(&self) -> u32 { + 0x8b6a + } + + #[napi(getter, js_name = "UNSIGNED_INT_VEC2")] + pub fn UNSIGNED_INT_VEC2(&self) -> u32 { + 0x8dc6 + } + + #[napi(getter, js_name = "UNSIGNED_INT_VEC3")] + pub fn UNSIGNED_INT_VEC3(&self) -> u32 { + 0x8dc7 + } + + #[napi(getter, js_name = "UNSIGNED_INT_VEC4")] + pub fn UNSIGNED_INT_VEC4(&self) -> u32 { + 0x8dc8 + } + + #[napi(getter, js_name = "UNSIGNED_NORMALIZED")] + pub fn UNSIGNED_NORMALIZED(&self) -> u32 { + 0x8c17 + } + + #[napi(getter, js_name = "SIGNED_NORMALIZED")] + pub fn SIGNED_NORMALIZED(&self) -> u32 { + 0x8f9c + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_INTEGER")] + pub fn VERTEX_ATTRIB_ARRAY_INTEGER(&self) -> u32 { + 0x88fd + } + + #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_DIVISOR")] + pub fn VERTEX_ATTRIB_ARRAY_DIVISOR(&self) -> u32 { + 0x88fe + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BUFFER_MODE")] + pub fn TRANSFORM_FEEDBACK_BUFFER_MODE(&self) -> u32 { + 0x8c7f + } + + #[napi(getter, js_name = "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS")] + pub fn MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS(&self) -> u32 { + 0x8c80 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_VARYINGS")] + pub fn TRANSFORM_FEEDBACK_VARYINGS(&self) -> u32 { + 0x8c83 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BUFFER_START")] + pub fn TRANSFORM_FEEDBACK_BUFFER_START(&self) -> u32 { + 0x8c84 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BUFFER_SIZE")] + pub fn TRANSFORM_FEEDBACK_BUFFER_SIZE(&self) -> u32 { + 0x8c85 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN")] + pub fn TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN(&self) -> u32 { + 0x8c88 + } + + #[napi(getter, js_name = "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS")] + pub fn MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS(&self) -> u32 { + 0x8c8a + } + + #[napi(getter, js_name = "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS")] + pub fn MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS(&self) -> u32 { + 0x8c8b + } + + #[napi(getter, js_name = "INTERLEAVED_ATTRIBS")] + pub fn INTERLEAVED_ATTRIBS(&self) -> u32 { + 0x8c8c + } + + #[napi(getter, js_name = "SEPARATE_ATTRIBS")] + pub fn SEPARATE_ATTRIBS(&self) -> u32 { + 0x8c8d + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BUFFER")] + pub fn TRANSFORM_FEEDBACK_BUFFER(&self) -> u32 { + 0x8c8e + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BUFFER_BINDING")] + pub fn TRANSFORM_FEEDBACK_BUFFER_BINDING(&self) -> u32 { + 0x8c8f + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK")] + pub fn TRANSFORM_FEEDBACK(&self) -> u32 { + 0x8e22 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_PAUSED")] + pub fn TRANSFORM_FEEDBACK_PAUSED(&self) -> u32 { + 0x8e23 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_ACTIVE")] + pub fn TRANSFORM_FEEDBACK_ACTIVE(&self) -> u32 { + 0x8e24 + } + + #[napi(getter, js_name = "TRANSFORM_FEEDBACK_BINDING")] + pub fn TRANSFORM_FEEDBACK_BINDING(&self) -> u32 { + 0x8e25 + } + + /* Pixel types */ + + /* Queries */ + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING")] + pub fn FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING(&self) -> u32 { + 0x8210 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE")] + pub fn FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE(&self) -> u32 { + 0x8211 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_RED_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_RED_SIZE(&self) -> u32 { + 0x8212 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_GREEN_SIZE(&self) -> u32 { + 0x8213 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_BLUE_SIZE(&self) -> u32 { + 0x8214 + } + /* Queries */ + + /* Draw buffers */ + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE(&self) -> u32 { + 0x8215 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE(&self) -> u32 { + 0x8216 + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE")] + pub fn FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE(&self) -> u32 { + 0x8217 + } + + #[napi(getter, js_name = "FRAMEBUFFER_DEFAULT")] + pub fn FRAMEBUFFER_DEFAULT(&self) -> u32 { + 0x8218 + } + + #[napi(getter, js_name = "DEPTH24_STENCIL8")] + pub fn DEPTH24_STENCIL8(&self) -> u32 { + 0x88f0 + } + + #[napi(getter, js_name = "DRAW_FRAMEBUFFER_BINDING")] + pub fn DRAW_FRAMEBUFFER_BINDING(&self) -> u32 { + 0x8ca6 + } + + #[napi(getter, js_name = "READ_FRAMEBUFFER")] + pub fn READ_FRAMEBUFFER(&self) -> u32 { + 0x8ca8 + } + + #[napi(getter, js_name = "DRAW_FRAMEBUFFER")] + pub fn DRAW_FRAMEBUFFER(&self) -> u32 { + 0x8ca9 + } + + #[napi(getter, js_name = "READ_FRAMEBUFFER_BINDING")] + pub fn READ_FRAMEBUFFER_BINDING(&self) -> u32 { + 0x8caa + } + + #[napi(getter, js_name = "RENDERBUFFER_SAMPLES")] + pub fn RENDERBUFFER_SAMPLES(&self) -> u32 { + 0x8cab + } + + #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER")] + pub fn FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER(&self) -> u32 { + 0x8cd4 + } + + #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE")] + pub fn FRAMEBUFFER_INCOMPLETE_MULTISAMPLE(&self) -> u32 { + 0x8d56 + } + + #[napi(getter, js_name = "UNIFORM_BUFFER")] + pub fn UNIFORM_BUFFER(&self) -> u32 { + 0x8a11 + } + + #[napi(getter, js_name = "UNIFORM_BUFFER_BINDING")] + pub fn UNIFORM_BUFFER_BINDING(&self) -> u32 { + 0x8a28 + } + + #[napi(getter, js_name = "UNIFORM_BUFFER_START")] + pub fn UNIFORM_BUFFER_START(&self) -> u32 { + 0x8a29 + } + + #[napi(getter, js_name = "UNIFORM_BUFFER_SIZE")] + pub fn UNIFORM_BUFFER_SIZE(&self) -> u32 { + 0x8a2a + } + + #[napi(getter, js_name = "MAX_VERTEX_UNIFORM_BLOCKS")] + pub fn MAX_VERTEX_UNIFORM_BLOCKS(&self) -> u32 { + 0x8a2b + } + + #[napi(getter, js_name = "MAX_FRAGMENT_UNIFORM_BLOCKS")] + pub fn MAX_FRAGMENT_UNIFORM_BLOCKS(&self) -> u32 { + 0x8a2d + } + + #[napi(getter, js_name = "MAX_COMBINED_UNIFORM_BLOCKS")] + pub fn MAX_COMBINED_UNIFORM_BLOCKS(&self) -> u32 { + 0x8a2e + } + + #[napi(getter, js_name = "MAX_UNIFORM_BUFFER_BINDINGS")] + pub fn MAX_UNIFORM_BUFFER_BINDINGS(&self) -> u32 { + 0x8a2f + } + + #[napi(getter, js_name = "MAX_UNIFORM_BLOCK_SIZE")] + pub fn MAX_UNIFORM_BLOCK_SIZE(&self) -> u32 { + 0x8a30 + } + + #[napi(getter, js_name = "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS")] + pub fn MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS(&self) -> u32 { + 0x8a31 + } + + #[napi(getter, js_name = "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS")] + pub fn MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS(&self) -> u32 { + 0x8a33 + } + + #[napi(getter, js_name = "UNIFORM_BUFFER_OFFSET_ALIGNMENT")] + pub fn UNIFORM_BUFFER_OFFSET_ALIGNMENT(&self) -> u32 { + 0x8a34 + } + + #[napi(getter, js_name = "ACTIVE_UNIFORM_BLOCKS")] + pub fn ACTIVE_UNIFORM_BLOCKS(&self) -> u32 { + 0x8a36 + } + + #[napi(getter, js_name = "UNIFORM_TYPE")] + pub fn UNIFORM_TYPE(&self) -> u32 { + 0x8a37 + } + + #[napi(getter, js_name = "UNIFORM_SIZE")] + pub fn UNIFORM_SIZE(&self) -> u32 { + 0x8a38 + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_INDEX")] + pub fn UNIFORM_BLOCK_INDEX(&self) -> u32 { + 0x8a3a + } + + #[napi(getter, js_name = "UNIFORM_OFFSET")] + pub fn UNIFORM_OFFSET(&self) -> u32 { + 0x8a3b + } + + #[napi(getter, js_name = "UNIFORM_ARRAY_STRIDE")] + pub fn UNIFORM_ARRAY_STRIDE(&self) -> u32 { + 0x8a3c + } + + #[napi(getter, js_name = "UNIFORM_MATRIX_STRIDE")] + pub fn UNIFORM_MATRIX_STRIDE(&self) -> u32 { + 0x8a3d + } + + /* Draw buffers */ + + /* Samplers */ + + #[napi(getter, js_name = "UNIFORM_IS_ROW_MAJOR")] + pub fn UNIFORM_IS_ROW_MAJOR(&self) -> u32 { + 0x8a3e + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_BINDING")] + pub fn UNIFORM_BLOCK_BINDING(&self) -> u32 { + 0x8a3f + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_DATA_SIZE")] + pub fn UNIFORM_BLOCK_DATA_SIZE(&self) -> u32 { + 0x8a40 + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_ACTIVE_UNIFORMS")] + pub fn UNIFORM_BLOCK_ACTIVE_UNIFORMS(&self) -> u32 { + 0x8a42 + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES")] + pub fn UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES(&self) -> u32 { + 0x8a43 + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER")] + pub fn UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER(&self) -> u32 { + 0x8a44 + } + + #[napi(getter, js_name = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER")] + pub fn UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER(&self) -> u32 { + 0x8a46 + } + + #[napi(getter, js_name = "OBJECT_TYPE")] + pub fn OBJECT_TYPE(&self) -> u32 { + 0x9112 + } + + #[napi(getter, js_name = "SYNC_CONDITION")] + pub fn SYNC_CONDITION(&self) -> u32 { + 0x9113 + } + + #[napi(getter, js_name = "SYNC_STATUS")] + pub fn SYNC_STATUS(&self) -> u32 { + 0x9114 + } + + #[napi(getter, js_name = "SYNC_FLAGS")] + pub fn SYNC_FLAGS(&self) -> u32 { + 0x9115 + } + + #[napi(getter, js_name = "SYNC_FENCE")] + pub fn SYNC_FENCE(&self) -> u32 { + 0x9116 + } + + #[napi(getter, js_name = "SYNC_GPU_COMMANDS_COMPLETE")] + pub fn SYNC_GPU_COMMANDS_COMPLETE(&self) -> u32 { + 0x9117 + } + + #[napi(getter, js_name = "UNSIGNALED")] + pub fn UNSIGNALED(&self) -> u32 { + 0x9118 + } + + #[napi(getter, js_name = "SIGNALED")] + pub fn SIGNALED(&self) -> u32 { + 0x9119 + } + + /* Samplers */ + + /* Buffers */ + + #[napi(getter, js_name = "ALREADY_SIGNALED")] + pub fn ALREADY_SIGNALED(&self) -> u32 { + 0x911a + } + + #[napi(getter, js_name = "TIMEOUT_EXPIRED")] + pub fn TIMEOUT_EXPIRED(&self) -> u32 { + 0x911b + } + + #[napi(getter, js_name = "CONDITION_SATISFIED")] + pub fn CONDITION_SATISFIED(&self) -> u32 { + 0x911c + } + + #[napi(getter, js_name = "WAIT_FAILED")] + pub fn WAIT_FAILED(&self) -> u32 { + 0x911d + } + + #[napi(getter, js_name = "SYNC_FLUSH_COMMANDS_BIT")] + pub fn SYNC_FLUSH_COMMANDS_BIT(&self) -> u32 { + 0x00000001 + } + + #[napi(getter, js_name = "COLOR")] + pub fn COLOR(&self) -> u32 { + 0x1800 + } + + #[napi(getter, js_name = "DEPTH")] + pub fn DEPTH(&self) -> u32 { + 0x1801 + } + + #[napi(getter, js_name = "STENCIL")] + pub fn STENCIL(&self) -> u32 { + 0x1802 + } + + /* Buffers */ + + /* Data types */ + + #[napi(getter, js_name = "MIN")] + pub fn MIN(&self) -> u32 { + return 0x8007; + } + + #[napi(getter, js_name = "MAX")] + pub fn MAX(&self) -> u32 { + return 0x8008; + } + + #[napi(getter, js_name = "DEPTH_COMPONENT24")] + pub fn DEPTH_COMPONENT24(&self) -> u32 { + return 0x81a6; + } + + #[napi(getter, js_name = "STREAM_READ")] + pub fn STREAM_READ(&self) -> u32 { + return 0x88e1; + } + + #[napi(getter, js_name = "STREAM_COPY")] + pub fn STREAM_COPY(&self) -> u32 { + return 0x88e2; + } + + #[napi(getter, js_name = "STATIC_READ")] + pub fn STATIC_READ(&self) -> u32 { + return 0x88e5; + } + + #[napi(getter, js_name = "STATIC_COPY")] + pub fn STATIC_COPY(&self) -> u32 { + return 0x88e6; + } + + + #[napi(getter, js_name = "DYNAMIC_READ")] + pub fn DYNAMIC_READ(&self) -> u32 { + return 0x88e9; + } + + #[napi(getter, js_name = "DYNAMIC_COPY")] + pub fn DYNAMIC_COPY(&self) -> u32 { + return 0x88ea; + } + + #[napi(getter, js_name = "DEPTH_COMPONENT32F")] + pub fn DEPTH_COMPONENT32F(&self) -> u32 { + return 0x8cac; + } + + #[napi(getter, js_name = "DEPTH32F_STENCIL8")] + pub fn DEPTH32F_STENCIL8(&self) -> u32 { + return 0x8cad; + } + + /* Data types */ + + #[napi(getter, js_name = "INVALID_INDEX")] + pub fn INVALID_INDEX(&self) -> u32 { + return 0xffffffff; + } + + #[napi(getter, js_name = "TIMEOUT_IGNORED")] + pub fn TIMEOUT_IGNORED(&self) -> i32 { + return -1; + } + + /* Vertex attributes */ + + /* Transform feedback */ + + #[napi(getter, js_name = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL")] + pub fn MAX_CLIENT_WAIT_TIMEOUT_WEBGL(&self) -> u32 { + return 0x9247; + } + } + }; +} diff --git a/napi/canvas-napi/src/gl/imports.rs b/napi/canvas-napi/src/gl/imports.rs new file mode 100644 index 000000000..8014bc9cf --- /dev/null +++ b/napi/canvas-napi/src/gl/imports.rs @@ -0,0 +1,33 @@ +#[macro_export] +macro_rules! webgl_context_imports { + () => { + use crate::gl::webgl_buffer::WebGLBuffer; + use crate::gl::webgl_framebuffer::WebGLFramebuffer; + use crate::gl::webgl_program::WebGLProgram; + use crate::gl::webgl_renderbuffer::WebGLRenderbuffer; + use crate::gl::webgl_shader::WebGLShader; + use crate::gl::webgl_texture::WebGLTexture; + use napi::*; + + use crate::gl::webgl_active_info::WebGLActiveInfo; + use crate::gl::webgl_shader_precision_format::WebGLShaderPrecisionFormat; + use crate::gl::webgl_uniform_location::WebGLUniformLocation; + use canvas_c::{WebGLExtension, WebGLResultType, WebGLState}; + use std::ffi::{c_void, CString, IntoStringError}; + + use crate::gl::extensions::{ + ANGLE_instanced_arrays, EXT_blend_minmax, EXT_color_buffer_half_float, + EXT_disjoint_timer_query, EXT_sRGB, EXT_shader_texture_lod, EXT_texture_filter_anisotropic, + OES_element_index_uint, OES_fbo_render_mipmap, OES_standard_derivatives, OES_texture_float, + OES_texture_float_linear, OES_texture_half_float, OES_texture_half_float_linear, + OES_vertex_array_object, WEBGL_color_buffer_float, WEBGL_compressed_texture_atc, + WEBGL_compressed_texture_etc, WEBGL_compressed_texture_etc1, WEBGL_compressed_texture_pvrtc, + WEBGL_compressed_texture_s3tc, WEBGL_depth_texture, WEBGL_draw_buffers, WEBGL_lose_context, + }; + use napi::bindgen_prelude::{ + Array, Buffer, ClassInstance, Either3, Either4, Either5, Float32Array, Int32Array, + ObjectFinalize, Uint32Array, Unknown, + }; + use std::sync::Arc; + }; +} diff --git a/napi/canvas-napi/src/gl/mod.rs b/napi/canvas-napi/src/gl/mod.rs index a6c01c360..9a8c48414 100644 --- a/napi/canvas-napi/src/gl/mod.rs +++ b/napi/canvas-napi/src/gl/mod.rs @@ -1,42 +1,31 @@ -mod webgl_program; -mod webgl_shader; -mod webgl_buffer; -mod webgl_framebuffer; -mod webgl_renderbuffer; -mod webgl_texture; -mod webgl_active_info; -mod context_attributes; -mod extensions; -mod webgl_shader_precision_format; -mod webgl_uniform_location; +pub mod webgl_program; +pub mod webgl_shader; +pub mod webgl_buffer; +pub mod webgl_framebuffer; +pub mod webgl_renderbuffer; +pub mod webgl_texture; +pub mod webgl_active_info; +pub mod context_attributes; +pub mod extensions; +pub mod webgl_shader_precision_format; +pub mod webgl_uniform_location; +pub mod base; +mod constants; +mod imports; -const UNPACK_FLIP_Y_WEBGL: u32 = 37440; -const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 = 37441; -const UNPACK_COLOR_SPACE_CONVERSION_WEBGL: u32 = 37443; -use crate::gl::extensions::{ANGLE_instanced_arrays, EXT_blend_minmax, EXT_color_buffer_half_float, EXT_disjoint_timer_query, EXT_sRGB, EXT_shader_texture_lod, EXT_texture_filter_anisotropic, OES_element_index_uint, OES_fbo_render_mipmap, OES_standard_derivatives, OES_texture_float, OES_texture_float_linear, OES_texture_half_float, OES_texture_half_float_linear, OES_vertex_array_object, WEBGL_color_buffer_float, WEBGL_compressed_texture_atc, WEBGL_compressed_texture_etc, WEBGL_compressed_texture_etc1, WEBGL_compressed_texture_pvrtc, WEBGL_compressed_texture_s3tc, WEBGL_depth_texture, WEBGL_draw_buffers, WEBGL_lose_context}; -use crate::gl::webgl_active_info::WebGLActiveInfo; -use crate::gl::webgl_buffer::WebGLBuffer; -use crate::gl::webgl_framebuffer::WebGLFramebuffer; -use crate::gl::webgl_program::WebGLProgram; -use crate::gl::webgl_renderbuffer::WebGLRenderbuffer; -use crate::gl::webgl_shader::WebGLShader; -use crate::gl::webgl_shader_precision_format::WebGLShaderPrecisionFormat; -use crate::gl::webgl_texture::WebGLTexture; -use crate::gl::webgl_uniform_location::WebGLUniformLocation; -use canvas_c::{WebGLExtension, WebGLResultType}; -use napi::bindgen_prelude::{Array, Buffer, ClassInstance, Either3, Either4, Float32Array, Int32Array, ObjectFinalize, Uint32Array, Unknown}; use napi::*; use napi_derive::napi; -use std::ffi::{c_void, CString, IntoStringError}; -use std::slice; -use std::sync::Arc; + +use crate::{impl_webgl_context, impl_webgl_context_constants}; #[napi(custom_finalize)] pub struct web_g_l_rendering_context { - state: *mut canvas_c::WebGLState, + pub(crate) state: *mut WebGLState, } + + impl ObjectFinalize for web_g_l_rendering_context { fn finalize(self, _: Env) -> Result<()> { canvas_c::canvas_native_webgl_state_destroy(self.state); @@ -44,28 +33,210 @@ impl ObjectFinalize for web_g_l_rendering_context { } } +impl_webgl_context!(web_g_l_rendering_context); + +pub(crate) fn get_parameter_inner(state: *mut canvas_c::WebGLState, env: Env, pname: u32) -> Result { + let mut consumed = false; + let result = canvas_c::canvas_native_webgl_get_parameter(pname, state); + + let parameter = match pname { + gl_bindings::ACTIVE_TEXTURE | + gl_bindings::ALPHA_BITS | + gl_bindings::ARRAY_BUFFER_BINDING | + gl_bindings::BLEND_DST_ALPHA | + gl_bindings::BLEND_DST_RGB | + gl_bindings::BLEND_EQUATION | + gl_bindings::BLEND_EQUATION_ALPHA | + gl_bindings::BLEND_SRC_ALPHA | + gl_bindings::BLEND_SRC_RGB | + gl_bindings::BLUE_BITS | + gl_bindings::CULL_FACE_MODE | + gl_bindings::CURRENT_PROGRAM | + gl_bindings::DEPTH_BITS | + gl_bindings::DEPTH_FUNC | + gl_bindings::ELEMENT_ARRAY_BUFFER_BINDING | + gl_bindings::FRAMEBUFFER_BINDING | + gl_bindings::FRONT_FACE | + gl_bindings::GENERATE_MIPMAP_HINT | + gl_bindings::GREEN_BITS | + gl_bindings::IMPLEMENTATION_COLOR_READ_FORMAT | + gl_bindings::IMPLEMENTATION_COLOR_READ_TYPE | + gl_bindings::MAX_COMBINED_TEXTURE_IMAGE_UNITS | + gl_bindings::MAX_CUBE_MAP_TEXTURE_SIZE | + gl_bindings::MAX_FRAGMENT_UNIFORM_VECTORS | + gl_bindings::MAX_RENDERBUFFER_SIZE | + gl_bindings::MAX_TEXTURE_IMAGE_UNITS | + gl_bindings::MAX_TEXTURE_SIZE | + gl_bindings::MAX_VARYING_VECTORS | + gl_bindings::MAX_VERTEX_ATTRIBS | + gl_bindings::MAX_VERTEX_TEXTURE_IMAGE_UNITS | + gl_bindings::MAX_VERTEX_UNIFORM_VECTORS | + gl_bindings::PACK_ALIGNMENT | + gl_bindings::RED_BITS | + gl_bindings::RENDERBUFFER_BINDING | + gl_bindings::SAMPLE_BUFFERS | + gl_bindings::SAMPLES | + gl_bindings::STENCIL_BACK_FAIL | + gl_bindings::STENCIL_BACK_FUNC | + gl_bindings::STENCIL_BACK_PASS_DEPTH_FAIL | + gl_bindings::STENCIL_BACK_PASS_DEPTH_PASS | + gl_bindings::STENCIL_BACK_REF | + gl_bindings::STENCIL_BACK_VALUE_MASK | + gl_bindings::STENCIL_BACK_WRITEMASK | + gl_bindings::STENCIL_BITS | + gl_bindings::STENCIL_CLEAR_VALUE | + gl_bindings::STENCIL_FAIL | + gl_bindings::STENCIL_FUNC | + gl_bindings::STENCIL_PASS_DEPTH_FAIL | + gl_bindings::STENCIL_PASS_DEPTH_PASS | + gl_bindings::STENCIL_REF | + gl_bindings::STENCIL_VALUE_MASK | + gl_bindings::STENCIL_WRITEMASK | + gl_bindings::SUBPIXEL_BITS | + gl_bindings::TEXTURE_BINDING_2D | + gl_bindings::TEXTURE_BINDING_CUBE_MAP | + gl_bindings::UNPACK_ALIGNMENT => { + let value = canvas_c::canvas_native_webgl_result_get_i32(result); + if (pname == gl_bindings::CURRENT_PROGRAM || pname == gl_bindings::ARRAY_BUFFER_BINDING || + pname == gl_bindings::ELEMENT_ARRAY_BUFFER_BINDING || + pname == gl_bindings::TEXTURE_BINDING_2D || + pname == gl_bindings::TEXTURE_BINDING_CUBE_MAP || + pname == gl_bindings::RENDERBUFFER_BINDING || + pname == gl_bindings::FRAMEBUFFER_BINDING) && + value == 0 { + return env.get_null().map(|v| v.into_unknown()); + } + + env.create_int32(value).map(|v| v.into_unknown()) + } + UNPACK_COLOR_SPACE_CONVERSION_WEBGL => { + let ret = canvas_c::canvas_native_webgl_state_get_unpack_colorspace_conversion_webgl(state); + env.create_int32(ret).map(|v| v.into_unknown()) + } + gl_bindings::ALIASED_LINE_WIDTH_RANGE | + gl_bindings::ALIASED_POINT_SIZE_RANGE | + gl_bindings::BLEND_COLOR | + gl_bindings::COLOR_CLEAR_VALUE | + gl_bindings::DEPTH_RANGE => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_f32_array(result); -#[napi] -impl web_g_l_rendering_context { - #[napi] - pub fn render(&self) { - canvas_c::canvas_native_webgl_make_current_and_swap_buffers(self.state); - } + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } - #[napi(getter)] - pub fn get_drawing_buffer_width(&self) -> i32 { - canvas_c::canvas_native_webgl_state_get_drawing_buffer_width(self.state) - } + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + consumed = true; + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Float32, + len, + 0, + ).map(|v| v.into_unknown()) + } + UNPACK_FLIP_Y_WEBGL => { + let ret = canvas_c::canvas_native_webgl_state_get_flip_y(state); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + UNPACK_PREMULTIPLY_ALPHA_WEBGL => { + let ret = canvas_c::canvas_native_webgl_state_get_premultiplied_alpha(state); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + gl_bindings::BLEND | + gl_bindings::CULL_FACE | + gl_bindings::DEPTH_TEST | + gl_bindings::DEPTH_WRITEMASK | + gl_bindings::DITHER | + gl_bindings::POLYGON_OFFSET_FILL | + gl_bindings::SAMPLE_COVERAGE_INVERT | + gl_bindings::SCISSOR_TEST | + gl_bindings::STENCIL_TEST => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + gl_bindings::COLOR_WRITEMASK => { + let ret = canvas_c::canvas_native_webgl_result_get_bool_array(result); + let len = canvas_c::canvas_native_u8_buffer_get_length(ret); + let buf = canvas_c::canvas_native_u8_buffer_get_bytes(ret); + let buf = unsafe { std::slice::from_raw_parts(buf, len) }; + let mut array = env.create_array(len as u32)?; + + for i in 0..len { + array.set(i as u32, buf[i] == 1)?; + } + array.coerce_to_object().map(|v| v.into_unknown()) + } + gl_bindings::COMPRESSED_TEXTURE_FORMATS | + gl_bindings::MAX_VIEWPORT_DIMS | + gl_bindings::SCISSOR_BOX | + gl_bindings::VIEWPORT => { + let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = unsafe { *Box::from_raw(ret) }; + let mut ret = ret.into_vec(); + + consumed = true; + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = unsafe { env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})? }; + buffer.value.into_typedarray( + TypedArrayType::Int32, + len, + 0, + ).map(|v| v.into_unknown()) + } + gl_bindings::DEPTH_CLEAR_VALUE | + gl_bindings::LINE_WIDTH | + gl_bindings::POLYGON_OFFSET_FACTOR | + gl_bindings::POLYGON_OFFSET_UNITS | + gl_bindings::SAMPLE_COVERAGE_VALUE => { + let ret = canvas_c::canvas_native_webgl_result_get_f32( + result); + env.create_double(ret as f64).map(|v| v.into_unknown()) + } + gl_bindings::RENDERER | + gl_bindings::SHADING_LANGUAGE_VERSION | + gl_bindings::VENDOR | + gl_bindings::VERSION => { + let ret = canvas_c::canvas_native_webgl_result_get_string(result); + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + let ret = unsafe { CString::from_raw(ret as _) }; + let ret = ret.into_string().map_err(|v| Error::from_reason(v.utf8_error().to_string()))?; + env.create_string_from_std(ret).map(|v| v.into_unknown()) + } + + _ => { + env.get_null().map(|v| v.into_unknown()) + } + }; - #[napi(getter)] - pub fn get_drawing_buffer_height(&self) -> i32 { - canvas_c::canvas_native_webgl_state_get_drawing_buffer_height(self.state) + if !consumed { + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); } + parameter +} + + +#[napi] +impl web_g_l_rendering_context { #[napi(factory)] pub fn with_view( view: i64, - version: i32, alpha: bool, antialias: bool, depth: bool, @@ -79,7 +250,7 @@ impl web_g_l_rendering_context { ) -> Result { let ret = canvas_c::canvas_native_webgl_create( view as _, - version, + 1, alpha, antialias, depth, @@ -105,7 +276,6 @@ impl web_g_l_rendering_context { pub fn offscreen( width: i32, height: i32, - version: i32, alpha: bool, antialias: bool, depth: bool, @@ -121,7 +291,7 @@ impl web_g_l_rendering_context { let ret = canvas_c::canvas_native_webgl_create_no_window( width, height, - version, + 1, alpha, antialias, depth, @@ -145,2496 +315,11 @@ impl web_g_l_rendering_context { } #[napi] - pub fn active_texture(&self, texture: u32) { - canvas_c::canvas_native_webgl_active_texture(texture, self.state); - } - - #[napi] - pub fn attach_shader(&self, program: ClassInstance, shader: ClassInstance) { - canvas_c::canvas_native_webgl_attach_shader(program.0, shader.0, self.state); - } - - - #[napi] - pub fn bind_attrib_location(&self, program: ClassInstance, index: u32, name: JsString) -> Result<()> { - let name = name.into_utf8()?; - let name = name.as_str()?; - let state = unsafe { &mut *self.state }; - unsafe { - canvas_webgl::webgl::canvas_native_webgl_bind_attrib_location( - program.0, index, name, state.get_inner_mut(), - ) - } - Ok(()) - } - - #[napi] - pub fn bind_buffer(&self, target: u32, buffer: ClassInstance) { - canvas_c::canvas_native_webgl_bind_buffer(target, buffer.0, self.state); - } - - #[napi] - pub fn bind_framebuffer(&self, target: u32, framebuffer: ClassInstance) { - canvas_c::canvas_native_webgl_bind_frame_buffer(target, framebuffer.0, self.state); - } - - #[napi] - pub fn bind_renderbuffer(&self, target: u32, renderbuffer: ClassInstance) { - canvas_c::canvas_native_webgl_bind_render_buffer(target, renderbuffer.0, self.state); - } - - #[napi] - pub fn bind_texture(&self, target: u32, texture: ClassInstance) { - canvas_c::canvas_native_webgl_bind_texture(target, texture.0, self.state); - } - - #[napi] - pub fn blend_color(&self, red: f64, green: f64, blue: f64, alpha: f64) { - canvas_c::canvas_native_webgl_blend_color(red as f32, green as f32, blue as f32, alpha as f32, self.state); - } - - #[napi] - pub fn blend_equation_separate(&self, mode_r_g_b: u32, mode_alpha: u32) { - canvas_c::canvas_native_webgl_blend_equation_separate(mode_r_g_b, mode_alpha, self.state) - } - - #[napi] - pub fn blend_equation(&self, mode: u32) { - canvas_c::canvas_native_webgl_blend_equation(mode, self.state) - } - - #[napi] - pub fn blend_func_separate(&self, src_r_g_b: Option, dst_r_g_b: Option, src_alpha: Option, dst_alpha: Option) { - let src_r_g_b = src_r_g_b.unwrap_or(1); - let dst_r_g_b = dst_r_g_b.unwrap_or(0); - let src_alpha = src_alpha.unwrap_or(1); - let dst_alpha = dst_alpha.unwrap_or(0); - canvas_c::canvas_native_webgl_blend_func_separate(src_r_g_b, dst_r_g_b, src_alpha, dst_alpha, self.state); - } - - #[napi] - pub fn blend_func(&self, sfactor: Option, dfactor: Option) { - let sfactor = sfactor.unwrap_or(1); - let dfactor = dfactor.unwrap_or(0); - canvas_c::canvas_native_webgl_blend_func(sfactor, dfactor, self.state); - } - - - #[napi] - pub fn buffer_data(&self, target: u32, size_or_src_data: Option>, usage: Option) { - match size_or_src_data { - Some(size_or_src_data) => { - match size_or_src_data { - Either::A(size) => { - match usage { - Some(usage) => { - canvas_c::canvas_native_webgl_buffer_data_none(target, size as isize, usage, self.state); - } - None => { - canvas_c::canvas_native_webgl_buffer_data_none(target, 0, size as u32, self.state); - } - } - } - Either::B(src_data) => { - if let Some(usage) = usage { - canvas_c::canvas_native_webgl_buffer_data(target, src_data.as_ptr(), src_data.len(), usage, self.state); - } - } - } - } - _ => { - if let Some(usage) = usage { - canvas_c::canvas_native_webgl_buffer_data_none(target, 0, usage, self.state); - } - } - } - } - - #[napi] - pub fn buffer_sub_data(&self, target: u32, offset: i64, src_data: &[u8]) { - canvas_c::canvas_native_webgl_buffer_sub_data( - target, offset as isize, src_data.as_ptr(), src_data.len(), self.state, - ) - } - - - #[napi] - pub fn check_framebuffer_status(&self, target: u32) -> u32 { - canvas_c::canvas_native_webgl_check_frame_buffer_status(target, self.state) - } - - #[napi] - pub fn clear_color(&self, - red: f64, - green: f64, - blue: f64, - alpha: f64) { - canvas_c::canvas_native_webgl_clear_color(red as f32, green as f32, blue as f32, alpha as f32, self.state); - } - - #[napi] - pub fn clear_depth(&self, depth: f64) { - canvas_c::canvas_native_webgl_clear_depth(depth as f32, self.state); - } - - #[napi] - pub fn clear_stencil(&self, stencil: i32) { - canvas_c::canvas_native_webgl_clear_stencil(stencil, self.state); - } - - #[napi] - pub fn clear(&self, mask: u32) { - canvas_c::canvas_native_webgl_clear(mask, self.state); - } - - #[napi] - pub fn color_mask(&self, red: bool, green: bool, blue: bool, alpha: bool) { - canvas_c::canvas_native_webgl_color_mask(red, green, blue, alpha, self.state); - } - - - #[napi] - pub fn commit(&self) { - canvas_c::canvas_native_webgl_commit(self.state); - } - - #[napi] - pub fn compile_shader(&self, shader: ClassInstance) { - canvas_c::canvas_native_webgl_compile_shader(shader.0, self.state); - } - - #[napi] - pub fn compressed_tex_image_2_d(&self, target: u32, level: i32, internalformat: u32, width: i64, height: i64, border: i32, pixels: &[u8]) { - canvas_c::canvas_native_webgl_compressed_tex_image2d( - target, level, internalformat, width as i32, height as i32, border, pixels.as_ptr(), pixels.len(), self.state, - ) - } - - #[napi] - pub fn compressed_tex_sub_image_2_d(&self, target: u32, level: i32, xoffset: i64, yoffset: i64, width: f64, height: f64, format: u32, pixels: &[u8]) { - canvas_c::canvas_native_webgl_compressed_tex_sub_image2d( - target, level, xoffset as i32, yoffset as i32, width as i32, height as i32, format, pixels.as_ptr(), pixels.len(), self.state, - ) - } - - #[napi] - pub fn copy_tex_image_2_d(&self, target: u32, level: i32, internalformat: u32, x: i64, y: i64, width: i64, height: i64, border: i32) { - canvas_c::canvas_native_webgl_copy_tex_image2d( - target, level, internalformat, x as i32, y as i32, width as i32, height as i32, border, self.state, - ) - } - - #[napi] - pub fn copy_tex_sub_image_2_d(&self, target: u32, level: i32, xoffset: i64, yoffset: i64, x: i64, y: i64, width: i64, height: i64) { - canvas_c::canvas_native_webgl_copy_tex_sub_image2d( - target, level, xoffset as i32, yoffset as i32, x as i32, y as i32, width as i32, height as i32, self.state, - ) - } - - #[napi] - pub fn create_buffer(&self, env: Env) -> Result> { - WebGLBuffer( - canvas_c::canvas_native_webgl_create_buffer(self.state) - ).into_instance(env) - } - - #[napi] - pub fn create_framebuffer(&self, env: Env) -> Result> { - WebGLFramebuffer(canvas_c::canvas_native_webgl_create_framebuffer(self.state)) - .into_instance(env) - } - - #[napi] - pub fn create_program(&self, env: Env) -> Result> { - WebGLProgram( - canvas_c::canvas_native_webgl_create_program(self.state) - ).into_instance(env) - } - #[napi] - - pub fn create_renderbuffer(&self, env: Env) -> Result> { - WebGLRenderbuffer( - canvas_c::canvas_native_webgl_create_renderbuffer(self.state) - ).into_instance(env) - } - - #[napi(ts_args_type = "type: number")] - pub fn create_shader(&self, env: Env, type_: u32) -> Result> { - WebGLShader( - canvas_c::canvas_native_webgl_create_shader(type_, self.state), - ).into_instance(env) - } - - #[napi] - pub fn create_texture(&self, env: Env) -> Result> { - WebGLTexture( - canvas_c::canvas_native_webgl_create_texture(self.state) - ).into_instance(env) - } - - #[napi] - pub fn cull_face(&self, mode: u32) { - canvas_c::canvas_native_webgl_cull_face(mode, self.state) - } - - - #[napi] - pub fn delete_buffer(&self, buffer: ClassInstance) { - canvas_c::canvas_native_webgl_delete_buffer(buffer.0, self.state) - } - - #[napi] - pub fn delete_framebuffer(&self, frame_buffer: ClassInstance) { - canvas_c::canvas_native_webgl_delete_framebuffer(frame_buffer.0, self.state) - } - - #[napi] - pub fn delete_program(&self, program: ClassInstance) { - canvas_c::canvas_native_webgl_delete_program(program.0, self.state) - } - - #[napi] - pub fn delete_renderbuffer(&self, render_buffer: ClassInstance) { - canvas_c::canvas_native_webgl_delete_renderbuffer(render_buffer.0, self.state) - } - - #[napi] - pub fn delete_shader(&self, shader: ClassInstance) { - canvas_c::canvas_native_webgl_delete_shader(shader.0, self.state) - } - - #[napi] - pub fn delete_texture(&self, texture: ClassInstance) { - canvas_c::canvas_native_webgl_delete_texture(texture.0, self.state) - } - - #[napi] - pub fn depth_func(&self, func: u32) { - canvas_c::canvas_native_webgl_depth_func(func, self.state); - } - - #[napi] - pub fn depth_mask(&self, flag: bool) { - canvas_c::canvas_native_webgl_depth_mask(flag, self.state); - } - - #[napi] - pub fn depth_range(&self, z_near: f64, z_far: f64) { - canvas_c::canvas_native_webgl_depth_range(z_near as f32, z_far as f32, self.state) - } - - #[napi] - pub fn detach_shader(&self, program: ClassInstance, shader: ClassInstance) { - canvas_c::canvas_native_webgl_detach_shader(program.0, shader.0, self.state) - } - - #[napi] - pub fn disable_vertex_attrib_array(&self, index: u32) { - canvas_c::canvas_native_webgl_disable_vertex_attrib_array(index, self.state); - } - - #[napi] - pub fn disable(&self, cap: u32) { - canvas_c::canvas_native_webgl_disable(cap, self.state); - } - - #[napi] - pub fn draw_arrays(&self, mode: u32, first: i32, count: i32) { - canvas_c::canvas_native_webgl_draw_arrays(mode, first, count, self.state); - } - - #[napi(ts_args_type = "mode: number, count: number, type: number, offset: number")] - pub fn draw_elements(&self, mode: u32, count: i32, type_: u32, offset: i64) { - canvas_c::canvas_native_webgl_draw_elements(mode, count, type_, offset as isize, self.state); - } - - #[napi] - pub fn enable_vertex_attrib_array(&self, index: u32) { - canvas_c::canvas_native_webgl_enable_vertex_attrib_array(index, self.state); - } - - #[napi] - pub fn enable(&self, cap: u32) { - canvas_c::canvas_native_webgl_enable(cap, self.state); - } - - #[napi] - pub fn finish(&self) { - canvas_c::canvas_native_webgl_finish(self.state); - } - - #[napi] - pub fn flush(&self) { - canvas_c::canvas_native_webgl_flush(self.state); - } - - #[napi] - pub fn framebuffer_renderbuffer(&self, target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: ClassInstance) { - canvas_c::canvas_native_webgl_framebuffer_renderbuffer(target, attachment, renderbuffertarget, renderbuffer.0, self.state) - } - - #[napi] - pub fn framebuffer_texture_2_d(&self, target: u32, attachment: u32, textarget: u32, texture: ClassInstance, level: i32) { - canvas_c::canvas_native_webgl_framebuffer_texture2d( - target, attachment, textarget, texture.0, level, self.state, - ) - } - - #[napi] - pub fn front_face(&self, mode: u32) { - canvas_c::canvas_native_webgl_front_face(mode, self.state) - } - - #[napi] - pub fn generate_mipmap(&self, target: u32) { - canvas_c::canvas_native_webgl_generate_mipmap(target, self.state); - } - - - #[napi] - pub fn get_active_attrib(&self, env: Env, program: ClassInstance, index: u32) -> Result> { - WebGLActiveInfo( - canvas_c::canvas_native_webgl_get_active_attrib( - program.0, index, self.state, - ) - ).into_instance(env) - } - - #[napi] - pub fn get_active_uniform(&self, env: Env, program: ClassInstance, index: u32) -> Result> { - WebGLActiveInfo( - canvas_c::canvas_native_webgl_get_active_uniform( - program.0, index, self.state, - ) - ).into_instance(env) - } - - #[napi] - pub fn get_attached_shaders(&self, env: Env, program: ClassInstance) -> Vec> { - let state = unsafe { &mut *self.state }; - let shaders = canvas_webgl::webgl::canvas_native_webgl_get_attached_shaders(program.0, state.get_inner_mut()); - shaders.into_iter() - .map(|shader| { - WebGLShader(shader).into_instance(env).unwrap() - }).collect::>() - } - - #[napi] - pub fn get_attrib_location(&self, program: ClassInstance, name: JsString) -> Result { - let name = name.into_utf8()?; - let name = name.as_str()?; - let state = unsafe { &mut *self.state }; - Ok(canvas_webgl::webgl::canvas_native_webgl_get_attrib_location(program.0, name, state.get_inner_mut())) - } - - #[napi] - pub fn get_buffer_parameter(&self, target: u32, pname: u32) -> i32 { - canvas_c::canvas_native_webgl_get_buffer_parameter(target, pname, self.state) - } - - #[napi] - pub fn get_context_attributes(&self) -> context_attributes::ContextAttributes { - let attributes = canvas_c::canvas_native_webgl_get_context_attributes(self.state); - let ret = context_attributes::ContextAttributes::from_c(attributes); - canvas_c::canvas_native_context_attributes_destroy(attributes); - ret - } - - #[napi] - pub fn get_error(&self) -> u32 { - canvas_c::canvas_native_webgl_get_error(self.state) - } - - #[napi] - pub fn get_extension(&self, env: Env, name: JsString) -> Result { - let name = name.into_utf8()?; - let name = name.as_str()?; - - if name == "EXT_disjoint_timer_query_webgl2" { - return env.get_null().map(|null| null.into_unknown()); - } - let state = unsafe { &mut *self.state }; - - let ext = canvas_webgl::webgl::canvas_native_webgl_get_extension( - name.as_ref(), - state.get_inner_mut(), - ); - - - match ext { - None => { - env.get_null().map(|null| null.into_unknown()) - } - Some(ext) => { - let ext = Box::into_raw(Box::new(WebGLExtension::new(Some(ext)))); - - match name { - "ANGLE_instanced_arrays" => { - let ret = canvas_c::canvas_native_webgl_context_extension_to_angle_instanced_arrays(ext); - ANGLE_instanced_arrays(ret) - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_blend_minmax" => { - if ext.is_null() { - return env.get_null().map(|null| null.into_unknown()); - } - canvas_c::canvas_native_webgl_extension_destroy(ext); - EXT_blend_minmax - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_color_buffer_half_float" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - EXT_color_buffer_half_float - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_disjoint_timer_query" => { - let ext = canvas_c::canvas_native_webgl_context_extension_to_ext_disjoint_timer_query(ext); - EXT_disjoint_timer_query(ext) - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_sRGB" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - EXT_sRGB - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_shader_texture_lod" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - EXT_shader_texture_lod - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "EXT_texture_filter_anisotropic" => { - EXT_texture_filter_anisotropic - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_element_index_uint" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_element_index_uint - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_standard_derivatives" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_standard_derivatives - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_texture_float" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_texture_float - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_texture_float_linear" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_texture_float_linear - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_texture_half_floatr" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_texture_half_float - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_texture_half_float_linear" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - OES_texture_half_float_linear - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_vertex_array_object" => { - let ext = canvas_c::canvas_native_webgl_context_extension_to_oes_vertex_array_object(ext); - OES_vertex_array_object(ext) - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_color_buffer_float" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_color_buffer_float - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_compressed_texture_atc" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_compressed_texture_atc - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_compressed_texture_etc" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_compressed_texture_etc - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_compressed_texture_etc1" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_compressed_texture_etc1 - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_compressed_texture_pvrtc" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_compressed_texture_pvrtc - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_compressed_texture_s3tc" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_compressed_texture_s3tc - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_lose_context" => { - let ext = canvas_c::canvas_native_webgl_context_extension_to_lose_context(ext); - WEBGL_lose_context(ext) - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_depth_texture" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - WEBGL_depth_texture - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "WEBGL_draw_buffers" => { - let ext = canvas_c::canvas_native_webgl_context_extension_to_draw_buffers(ext); - WEBGL_draw_buffers(ext) - .into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - "OES_fbo_render_mipmap" => { - canvas_c::canvas_native_webgl_extension_destroy(ext); - - OES_fbo_render_mipmap.into_instance(env).map(|ext| ext.as_object(env).into_unknown()) - } - _ => env.get_null().map(|null| null.into_unknown()), - } - } - } - } - - #[napi] - pub fn get_framebuffer_attachment_parameter(&self, env: Env, target: u32, attachment: u32, pname: u32) -> Result { - let mut state = unsafe { &mut *self.state }; - let ret = canvas_webgl::webgl::canvas_native_webgl_get_framebuffer_attachment_parameter( - target, - attachment, - pname, - state.get_inner_mut(), - ); - - - if ret.get_is_renderbuffer() { - return WebGLRenderbuffer(ret.get_value() as _) - .into_instance(env).map(|v| v.as_object(env).into_unknown()); - } else if ret.get_is_texture() { - return WebGLTexture(ret.get_value() as _) - .into_instance(env).map(|v| v.as_object(env).into_unknown()) - } - - env.create_int32(ret.get_value() as _).map(|v| v.into_unknown()) + pub fn get_parameter(&self, env: Env, pname: u32) -> Result { + get_parameter_inner(self.state, env, pname) } +} - #[napi] - pub fn get_parameter(&self, env: Env, pname: u32) -> Result { - let mut consumed = false; - let result = canvas_c::canvas_native_webgl_get_parameter(pname, self.state); - - let parameter = match pname { - gl_bindings::ACTIVE_TEXTURE | - gl_bindings::ALPHA_BITS | - gl_bindings::ARRAY_BUFFER_BINDING | - gl_bindings::BLEND_DST_ALPHA | - gl_bindings::BLEND_DST_RGB | - gl_bindings::BLEND_EQUATION | - gl_bindings::BLEND_EQUATION_ALPHA | - gl_bindings::BLEND_SRC_ALPHA | - gl_bindings::BLEND_SRC_RGB | - gl_bindings::BLUE_BITS | - gl_bindings::CULL_FACE_MODE | - gl_bindings::CURRENT_PROGRAM | - gl_bindings::DEPTH_BITS | - gl_bindings::DEPTH_FUNC | - gl_bindings::ELEMENT_ARRAY_BUFFER_BINDING | - gl_bindings::FRAMEBUFFER_BINDING | - gl_bindings::FRONT_FACE | - gl_bindings::GENERATE_MIPMAP_HINT | - gl_bindings::GREEN_BITS | - gl_bindings::IMPLEMENTATION_COLOR_READ_FORMAT | - gl_bindings::IMPLEMENTATION_COLOR_READ_TYPE | - gl_bindings::MAX_COMBINED_TEXTURE_IMAGE_UNITS | - gl_bindings::MAX_CUBE_MAP_TEXTURE_SIZE | - gl_bindings::MAX_FRAGMENT_UNIFORM_VECTORS | - gl_bindings::MAX_RENDERBUFFER_SIZE | - gl_bindings::MAX_TEXTURE_IMAGE_UNITS | - gl_bindings::MAX_TEXTURE_SIZE | - gl_bindings::MAX_VARYING_VECTORS | - gl_bindings::MAX_VERTEX_ATTRIBS | - gl_bindings::MAX_VERTEX_TEXTURE_IMAGE_UNITS | - gl_bindings::MAX_VERTEX_UNIFORM_VECTORS | - gl_bindings::PACK_ALIGNMENT | - gl_bindings::RED_BITS | - gl_bindings::RENDERBUFFER_BINDING | - gl_bindings::SAMPLE_BUFFERS | - gl_bindings::SAMPLES | - gl_bindings::STENCIL_BACK_FAIL | - gl_bindings::STENCIL_BACK_FUNC | - gl_bindings::STENCIL_BACK_PASS_DEPTH_FAIL | - gl_bindings::STENCIL_BACK_PASS_DEPTH_PASS | - gl_bindings::STENCIL_BACK_REF | - gl_bindings::STENCIL_BACK_VALUE_MASK | - gl_bindings::STENCIL_BACK_WRITEMASK | - gl_bindings::STENCIL_BITS | - gl_bindings::STENCIL_CLEAR_VALUE | - gl_bindings::STENCIL_FAIL | - gl_bindings::STENCIL_FUNC | - gl_bindings::STENCIL_PASS_DEPTH_FAIL | - gl_bindings::STENCIL_PASS_DEPTH_PASS | - gl_bindings::STENCIL_REF | - gl_bindings::STENCIL_VALUE_MASK | - gl_bindings::STENCIL_WRITEMASK | - gl_bindings::SUBPIXEL_BITS | - gl_bindings::TEXTURE_BINDING_2D | - gl_bindings::TEXTURE_BINDING_CUBE_MAP | - gl_bindings::UNPACK_ALIGNMENT => { - let value = canvas_c::canvas_native_webgl_result_get_i32(result); - if (pname == gl_bindings::CURRENT_PROGRAM || pname == gl_bindings::ARRAY_BUFFER_BINDING || - pname == gl_bindings::ELEMENT_ARRAY_BUFFER_BINDING || - pname == gl_bindings::TEXTURE_BINDING_2D || - pname == gl_bindings::TEXTURE_BINDING_CUBE_MAP || - pname == gl_bindings::RENDERBUFFER_BINDING || - pname == gl_bindings::FRAMEBUFFER_BINDING) && - value == 0 { - return env.get_null().map(|v| v.into_unknown()); - } - - env.create_int32(value).map(|v| v.into_unknown()) - } - UNPACK_COLOR_SPACE_CONVERSION_WEBGL => { - let ret = canvas_c::canvas_native_webgl_state_get_unpack_colorspace_conversion_webgl(self.state); - env.create_int32(ret).map(|v| v.into_unknown()) - } - gl_bindings::ALIASED_LINE_WIDTH_RANGE | - gl_bindings::ALIASED_POINT_SIZE_RANGE | - gl_bindings::BLEND_COLOR | - gl_bindings::COLOR_CLEAR_VALUE | - gl_bindings::DEPTH_RANGE => unsafe { - let ret = canvas_c::canvas_native_webgl_result_into_f32_array(result); - - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = *Box::from_raw(ret); - let mut ret = ret.into_vec(); - - consumed = true; - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - - let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; - buffer.value.into_typedarray( - TypedArrayType::Float32, - len, - 0, - ).map(|v| v.into_unknown()) - } - UNPACK_FLIP_Y_WEBGL => { - let ret = canvas_c::canvas_native_webgl_state_get_flip_y(self.state); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - UNPACK_PREMULTIPLY_ALPHA_WEBGL => { - let ret = canvas_c::canvas_native_webgl_state_get_premultiplied_alpha(self.state); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - gl_bindings::BLEND | - gl_bindings::CULL_FACE | - gl_bindings::DEPTH_TEST | - gl_bindings::DEPTH_WRITEMASK | - gl_bindings::DITHER | - gl_bindings::POLYGON_OFFSET_FILL | - gl_bindings::SAMPLE_COVERAGE_INVERT | - gl_bindings::SCISSOR_TEST | - gl_bindings::STENCIL_TEST => { - let ret = canvas_c::canvas_native_webgl_result_get_bool(result); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - gl_bindings::COLOR_WRITEMASK => { - let ret = canvas_c::canvas_native_webgl_result_get_bool_array(result); - let len = canvas_c::canvas_native_u8_buffer_get_length(ret); - let buf = canvas_c::canvas_native_u8_buffer_get_bytes(ret); - let buf = unsafe { slice::from_raw_parts(buf, len) }; - let mut array = env.create_array(len as u32)?; - - for i in 0..len { - array.set(i as u32, buf[i] == 1)?; - } - array.coerce_to_object().map(|v| v.into_unknown()) - } - gl_bindings::COMPRESSED_TEXTURE_FORMATS | - gl_bindings::MAX_VIEWPORT_DIMS | - gl_bindings::SCISSOR_BOX | - gl_bindings::VIEWPORT => { - let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); - - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = unsafe { *Box::from_raw(ret) }; - let mut ret = ret.into_vec(); - - consumed = true; - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - let buffer = unsafe { env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})? }; - buffer.value.into_typedarray( - TypedArrayType::Int32, - len, - 0, - ).map(|v| v.into_unknown()) - } - gl_bindings::DEPTH_CLEAR_VALUE | - gl_bindings::LINE_WIDTH | - gl_bindings::POLYGON_OFFSET_FACTOR | - gl_bindings::POLYGON_OFFSET_UNITS | - gl_bindings::SAMPLE_COVERAGE_VALUE => { - let ret = canvas_c::canvas_native_webgl_result_get_f32( - result); - env.create_double(ret as f64).map(|v| v.into_unknown()) - } - gl_bindings::RENDERER | - gl_bindings::SHADING_LANGUAGE_VERSION | - gl_bindings::VENDOR | - gl_bindings::VERSION => { - let ret = canvas_c::canvas_native_webgl_result_get_string(result); - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - let ret = unsafe { CString::from_raw(ret as _) }; - let ret = ret.into_string().map_err(|v| Error::from_reason(v.utf8_error().to_string()))?; - env.create_string_from_std(ret).map(|v| v.into_unknown()) - } - - _ => { - env.get_null().map(|v| v.into_unknown()) - } - }; - - if !consumed { - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - } - - parameter - } - - - #[napi] - pub fn get_program_info_log(&self, program: ClassInstance) -> String { - let state = unsafe { &mut *self.state }; - canvas_webgl::webgl::canvas_native_webgl_get_program_info_log(program.0, state.get_inner_mut()) - } - - #[napi] - pub fn get_program_parameter(&self, env: Env, program: ClassInstance, pname: u32) -> Result { - let result = canvas_c::canvas_native_webgl_get_program_parameter(program.0, pname, self.state); - if canvas_c::canvas_native_webgl_result_get_is_none(result) { - // todo - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - return env.get_null().map(|v| v.into_unknown()); - } - - - match pname { - gl_bindings::DELETE_STATUS | - gl_bindings::LINK_STATUS | - gl_bindings::VALIDATE_STATUS => { - let ret = canvas_c::canvas_native_webgl_result_get_bool(result); - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - _ => { - let ret = canvas_c::canvas_native_webgl_result_get_i32(result); - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - env.create_int32(ret).map(|v| v.into_unknown()) - } - } - } - - - #[napi] - pub fn get_renderbuffer_parameter(&self, target: u32, pname: u32) -> i32 { - canvas_c::canvas_native_webgl_get_renderbuffer_parameter(target, pname, self.state) - } - - #[napi] - pub fn get_shader_info_log(&self, shader: ClassInstance) -> String { - let state = unsafe { &mut *self.state }; - canvas_webgl::webgl::canvas_native_webgl_get_shader_info_log(shader.0, state.get_inner_mut()) - } - - #[napi] - pub fn get_shader_parameter(&self, env: Env, shader: ClassInstance, pname: u32) -> Result { - let result = canvas_c::canvas_native_webgl_get_shader_parameter(shader.0, pname, self.state); - match pname { - gl_bindings::DELETE_STATUS | gl_bindings::COMPILE_STATUS => { - let ret = canvas_c::canvas_native_webgl_result_get_bool(result); - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - _ => { - let ret = canvas_c::canvas_native_webgl_result_get_i32(result); - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - env.create_int32(ret).map(|v| v.into_unknown()) - } - } - } - - #[napi] - pub fn get_shader_precision_format(&self, env: Env, shader_type: u32, precision_type: u32) -> Result> { - let precision = canvas_c::canvas_native_webgl_get_shader_precision_format(shader_type, precision_type, self.state); - WebGLShaderPrecisionFormat(precision) - .into_instance(env) - } - - #[napi] - pub fn get_shader_source(&self, shader: ClassInstance) -> String { - let state = unsafe { &mut *self.state }; - canvas_webgl::webgl::canvas_native_webgl_get_shader_source(shader.0, state.get_inner_mut()) - } - - #[napi] - pub fn get_supported_extensions(&self) -> Vec { - let state = unsafe { &mut *self.state }; - canvas_webgl::webgl::canvas_native_webgl_get_supported_extensions(state.get_inner_mut()) - } - - #[napi] - pub fn get_tex_parameter(&self, target: u32, pname: u32) -> i32 { - canvas_c::canvas_native_webgl_get_tex_parameter(target, pname, self.state) - } - - #[napi] - pub fn get_uniform_location(&self, env: Env, program: ClassInstance, name: String) -> Result { - let state = unsafe { &mut *self.state }; - let location = canvas_webgl::webgl::canvas_native_webgl_get_uniform_location(program.0, name.as_str(), state.get_inner_mut()); - - if location == -1 { - return env.get_null().map(|v| v.into_unknown()); - } - - webgl_uniform_location::WebGLUniformLocation(location) - .into_instance(env) - .map(|v| v.as_object(env).into_unknown()) - } - - #[napi] - pub fn get_uniform(&self, env: Env, program: ClassInstance, location: ClassInstance) -> Result { - let result = canvas_c::canvas_native_webgl_get_uniform(program.0, location.0, self.state); - let type_ = canvas_c::canvas_native_webgl_result_get_type(result); - let uniform = match type_ { - WebGLResultType::Boolean => { - let ret = canvas_c::canvas_native_webgl_result_get_bool(result); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - WebGLResultType::I32Array => unsafe { - let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); - - - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = *Box::from_raw(ret); - let mut ret = ret.into_vec(); - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; - buffer.value.into_typedarray( - TypedArrayType::Int32, - len, - 0, - ).map(|v| v.into_unknown()) - } - WebGLResultType::U32Array => unsafe { - let ret = canvas_c::canvas_native_webgl_result_into_u32_array(result); - - - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = *Box::from_raw(ret); - let mut ret = ret.into_vec(); - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; - buffer.value.into_typedarray( - TypedArrayType::Uint32, - len, - 0, - ).map(|v| v.into_unknown()) - } - WebGLResultType::F32Array => unsafe { - let ret = canvas_c::canvas_native_webgl_result_into_f32_array(result); - - - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = *Box::from_raw(ret); - let mut ret = ret.into_vec(); - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; - buffer.value.into_typedarray( - TypedArrayType::Float32, - len, - 0, - ).map(|v| v.into_unknown()) - } - WebGLResultType::BooleanArray => { - let ret = canvas_c::canvas_native_webgl_result_get_bool_array(result); - let len = canvas_c::canvas_native_u8_buffer_get_length(ret); - let buf = canvas_c::canvas_native_u8_buffer_get_bytes(ret); - let buf = unsafe { slice::from_raw_parts(buf, len) }; - let mut array = env.create_array(len as u32)?; - - for i in 0..len { - array.set(i as u32, buf[i] == 1)?; - } - array.coerce_to_object().map(|v| v.into_unknown()) - } - WebGLResultType::U32 => { - let ret = canvas_c::canvas_native_webgl_result_get_u32(result); - env.create_uint32(ret).map(|v| v.into_unknown()) - } - WebGLResultType::I32 => { - let ret = canvas_c::canvas_native_webgl_result_get_i32(result); - env.create_int32(ret).map(|v| v.into_unknown()) - } - WebGLResultType::F32 => { - let ret = canvas_c::canvas_native_webgl_result_get_f32(result); - env.create_double(ret as f64).map(|v| v.into_unknown()) - } - WebGLResultType::String => unsafe { - let ret = canvas_c::canvas_native_webgl_result_get_string(result); - if ret.is_null() { - return Err(Error::from_status(Status::GenericFailure)); - } - let ret = CString::from_raw(ret as _); - match ret.into_string() { - Ok(s) => env.create_string_from_std(s), - Err(_) => Err(Error::from_status(Status::GenericFailure)), - }.map(|v| v.into_unknown()) - } - WebGLResultType::None => { - env.get_null().map(|v| v.into_unknown()) - } - }; - - canvas_c::canvas_native_webgl_WebGLResult_destroy(result); - - uniform - } - - #[napi] - pub fn get_vertex_attrib_offset(&self, index: u32, pname: u32) -> i64 { - canvas_c::canvas_native_webgl_get_vertex_attrib_offset(index, pname, self.state) as i64 - } - - #[napi] - pub fn get_vertex_attrib(&self, env: Env, index: u32, pname: u32) -> Result { - let result = canvas_c::canvas_native_webgl_get_vertex_attrib(index, pname, self.state); - - match pname { - gl_bindings::CURRENT_VERTEX_ATTRIB => unsafe { - let ret = canvas_c::canvas_native_webgl_result_get_f32_array(result); - if ret.is_null() { - return env.get_null().map(|v| v.into_unknown()); - } - - let ret = *Box::from_raw(ret); - let mut ret = ret.into_vec(); - - let ptr = ret.as_mut_ptr(); - let len = ret.len(); - - let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; - buffer.value.into_typedarray( - TypedArrayType::Float32, - len, - 0, - ).map(|v| v.into_unknown()) - } - gl_bindings::VERTEX_ATTRIB_ARRAY_ENABLED | gl_bindings::VERTEX_ATTRIB_ARRAY_NORMALIZED => { - let ret = canvas_c::canvas_native_webgl_result_get_bool(result); - env.get_boolean(ret).map(|v| v.into_unknown()) - } - _ => { - let ret = canvas_c::canvas_native_webgl_result_get_i32(result); - env.create_int32(ret).map(|v| v.into_unknown()) - } - } - } - - #[napi] - pub fn hint(&self, target: u32, mode: u32) { - canvas_c::canvas_native_webgl_hint(target, mode, self.state); - } - - - #[napi] - pub fn is_buffer(&self, buffer: ClassInstance) -> bool { - canvas_c::canvas_native_webgl_is_buffer(buffer.0, self.state) - } - - #[napi] - pub fn is_context_lost(&self) -> bool { - canvas_c::canvas_native_webgl_get_is_context_lost(self.state) - } - - #[napi] - pub fn is_enabled(&self, cap: u32) -> bool { - canvas_c::canvas_native_webgl_is_enabled(cap, self.state) - } - - #[napi] - pub fn is_framebuffer(&self, framebuffer: Option>) -> bool { - let framebuffer = match framebuffer { - None => 0, - Some(framebuffer) => framebuffer.0 - }; - canvas_c::canvas_native_webgl_is_framebuffer(framebuffer, self.state) - } - - #[napi] - pub fn is_program(&self, program: ClassInstance) -> bool { - canvas_c::canvas_native_webgl_is_program(program.0, self.state) - } - - #[napi] - pub fn is_renderbuffer(&self, renderbuffer: ClassInstance) -> bool { - canvas_c::canvas_native_webgl_is_renderbuffer(renderbuffer.0, self.state) - } - - #[napi] - pub fn is_shader(&self, shader: ClassInstance) -> bool { - canvas_c::canvas_native_webgl_is_shader(shader.0, self.state) - } - - #[napi] - pub fn is_texture(&self, texture: ClassInstance) -> bool { - canvas_c::canvas_native_webgl_is_texture(texture.0, self.state) - } - - #[napi] - pub fn line_width(&self, width: f64) { - canvas_c::canvas_native_webgl_line_width(width as f32, self.state); - } - - #[napi] - pub fn link_program(&self, program: ClassInstance) { - canvas_c::canvas_native_webgl_link_program(program.0, self.state) - } - - #[napi] - pub fn pixel_storei(&self, pname: u32, param: Either) { - match param { - Either::A(param) => { - let param = if param { 1 } else { 0 }; - match pname { - UNPACK_FLIP_Y_WEBGL | UNPACK_PREMULTIPLY_ALPHA_WEBGL => { - canvas_c::canvas_native_webgl_pixel_storei(pname, param, self.state) - } - _ => {} - } - } - Either::B(param) => { - match pname { - UNPACK_COLORSPACE_CONVERSION_WEBGL => { - canvas_c::canvas_native_webgl_pixel_storei(pname, 0x9244, self.state) - } - _ => { - canvas_c::canvas_native_webgl_pixel_storei(pname, param, self.state) - } - } - } - } - } - - - #[napi] - pub fn polygon_offset(&self, factor: f64, units: f64) { - canvas_c::canvas_native_webgl_polygon_offset(factor as f32, units as f32, self.state) - } - - #[napi( - ts_args_type = "x: number, y: number, width: number, height: number, format: number, type: number, pixels: ArrayBuffer | ArrayBufferView" - )] - pub fn read_pixels(&self, x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, mut pixels: Buffer) { - // todo - canvas_c::canvas_native_webgl_read_pixels_u8( - x, y, width, height, format, type_, pixels.as_mut_ptr(), pixels.len(), self.state, - ) - } - - #[napi] - pub fn renderbuffer_storage(&self, target: u32, internal_format: u32, width: i32, height: i32) { - let mut internal_format = internal_format; - if (internal_format == gl_bindings::DEPTH_STENCIL) { - // DEPTH24_STENCIL8 = 35056 - // DEPTH24_STENCIL8_OES = 0x88F0 - internal_format = 0x88f0; - } - canvas_c::canvas_native_webgl_renderbuffer_storage(target, internal_format, width, height, self.state) - } - - #[napi] - pub fn sample_coverage(&self, value: f64, invert: bool) { - canvas_c::canvas_native_webgl_sample_coverage(value as f32, invert, self.state); - } - - #[napi] - pub fn scissor(&self, x: i32, y: i32, width: i32, height: i32) { - canvas_c::canvas_native_webgl_scissor(x, y, width, height, self.state) - } - - #[napi] - pub fn shader_source(&self, shader: ClassInstance, source: String) { - let state = unsafe { &mut *self.state }; - canvas_webgl::webgl::canvas_native_webgl_shader_source(shader.0, source.as_str(), state.get_inner_mut()); - } - - #[napi(ts_args_type = "face:number, func: number, ref: number, mask: number")] - pub fn stencil_func_separate(&self, face: u32, func: u32, ref_: i32, mask: u32) { - canvas_c::canvas_native_webgl_stencil_func_separate(face, func, ref_, mask, self.state) - } - - #[napi(ts_args_type = "func: number, ref: number, mask: number")] - pub fn stencil_func(&self, func: u32, ref_: i32, mask: u32) { - canvas_c::canvas_native_webgl_stencil_func(func, ref_, mask, self.state) - } - - #[napi] - pub fn stencil_mask_separate(&self, face: u32, mask: u32) { - canvas_c::canvas_native_webgl_stencil_mask_separate(face, mask, self.state); - } - - #[napi] - pub fn stencil_mask(&self, mask: u32) { - canvas_c::canvas_native_webgl_stencil_mask(mask, self.state); - } - - #[napi] - pub fn stencil_op_separate(&self, face: u32, fail: u32, zfail: u32, zpass: u32) { - canvas_c::canvas_native_webgl_stencil_op_separate(face, fail, zfail, zpass, self.state); - } - - #[napi] - pub fn stencil_op(&self, fail: u32, zfail: u32, zpass: u32) { - canvas_c::canvas_native_webgl_stencil_op(fail, zfail, zpass, self.state); - } - - - // texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: any): void; - // - // texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void; - - #[napi] - pub fn tex_image_2D(&self, target: i32, level: i32, internalformat: i32, width_or_format: i32, height_or_type: i32, border_or_pixels: Either4, ClassInstance, ClassInstance>, format: Option, type_: Option, pixels: Option>, offset: Option) -> Result<()> { - match border_or_pixels { - Either4::A(border) => { - match (format, type_, pixels) { - (Some(format), Some(type_), Some(pixels)) => { - match pixels { - Either::A(buffer) => { - canvas_c::canvas_native_webgl_tex_image2d( - target, level, internalformat, width_or_format, height_or_type, border, format, type_, buffer.as_ptr(), buffer.len(), self.state, - ) - } - Either::B(offset) => { - canvas_c::canvas_native_webgl2_tex_image2d_offset( - target, level, internalformat, width_or_format as u32, height_or_type as u32, border, format, type_, offset as u64, self.state, - ) - } - } - } - (Some(format), Some(type_), None) => { - canvas_c::canvas_native_webgl_tex_image2d_none( - target, level, internalformat, width_or_format, height_or_type, border, format, type_, self.state, - ) - } - _ => {} - } - } - Either4::B(c2d) => { - canvas_c::canvas_native_webgl_tex_image2d_canvas2d( - target, level, internalformat, width_or_format, height_or_type, c2d.context, self.state, - ) - } - Either4::C(gl) => { - canvas_c::canvas_native_webgl_tex_image2d_webgl( - target, level, internalformat, width_or_format, height_or_type, gl.state, self.state, - ) - } - Either4::D(image) => { - canvas_c::canvas_native_webgl_tex_image2d_image_asset( - target, level, internalformat, width_or_format, height_or_type, Arc::as_ptr(&image.asset), self.state, - ) - } - } - Ok(()) - } - - - #[napi] - pub fn tex_parameterf(&self, target: u32, pname: u32, param: f64) { - canvas_c::canvas_native_webgl_tex_parameterf(target, pname, param as f32, self.state); - } - - #[napi] - pub fn tex_parameteri(&self, target: u32, pname: u32, param: i32) { - canvas_c::canvas_native_webgl_tex_parameteri(target, pname, param, self.state); - } - - - #[napi(js_name = "uniform1f")] - pub fn uniform1f(&self, location: ClassInstance, v0: f64) { - canvas_c::canvas_native_webgl_uniform1f(location.0, v0 as f32, self.state); - } - - - #[napi(js_name = "uniform1iv")] - pub fn uniform1iv(&self, location: ClassInstance, value: Either, Int32Array>) { - match value { - Either::A(array) => { - canvas_c::canvas_native_webgl_uniform1iv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform1iv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform1fv")] - pub fn uniform1fv(&self, location: ClassInstance, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform1fv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform1fv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform1i")] - pub fn uniform1i(&self, location: ClassInstance, v0: i32) { - canvas_c::canvas_native_webgl_uniform1i(location.0, v0, self.state); - } - - #[napi(js_name = "uniform2f")] - pub fn uniform2f(&self, location: ClassInstance, v0: f64, v1: f64) { - canvas_c::canvas_native_webgl_uniform2f(location.0, v0 as f32, v1 as f32, self.state); - } - - #[napi(js_name = "uniform2iv")] - pub fn uniform2iv(&self, location: ClassInstance, value: Either, Int32Array>) { - match value { - Either::A(array) => { - canvas_c::canvas_native_webgl_uniform2iv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform2iv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform2fv")] - pub fn uniform2fv(&self, location: ClassInstance, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform2fv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform2fv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform2i")] - pub fn uniform2i(&self, location: ClassInstance, v0: i32, v1: i32) { - canvas_c::canvas_native_webgl_uniform2i(location.0, v0, v1, self.state); - } - - #[napi(js_name = "uniform3f")] - pub fn uniform3f(&self, location: ClassInstance, v0: f64, v1: f64, v2: f64) { - canvas_c::canvas_native_webgl_uniform3f(location.0, v0 as f32, v1 as f32, v2 as f32, self.state); - } - - #[napi(js_name = "uniform3iv")] - pub fn uniform3iv(&self, location: ClassInstance, value: Either, Int32Array>) { - match value { - Either::A(array) => { - canvas_c::canvas_native_webgl_uniform3iv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform3iv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform3fv")] - pub fn uniform3fv(&self, location: ClassInstance, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform3fv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform3fv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform3i")] - pub fn uniform3i(&self, location: ClassInstance, v0: i32, v1: i32, v2: i32) { - canvas_c::canvas_native_webgl_uniform3i(location.0, v0, v1, v2, self.state); - } - - #[napi(js_name = "uniform4f")] - pub fn uniform4f(&self, location: ClassInstance, v0: f64, v1: f64, v2: f64, v3: f64) { - canvas_c::canvas_native_webgl_uniform4f(location.0, v0 as f32, v1 as f32, v2 as f32, v3 as f32, self.state); - } - - #[napi(js_name = "uniform4iv")] - pub fn uniform4iv(&self, location: ClassInstance, value: Either, Int32Array>) { - match value { - Either::A(array) => { - canvas_c::canvas_native_webgl_uniform4iv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform4iv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform4fv")] - pub fn uniform4fv(&self, location: ClassInstance, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform4fv(location.0, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform4fv(location.0, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniform4i")] - pub fn uniform4i(&self, location: ClassInstance, v0: i32, v1: i32, v2: i32, v3: i32) { - canvas_c::canvas_native_webgl_uniform4i(location.0, v0, v1, v2, v3, self.state); - } - - #[napi(js_name = "uniformMatrix2fv")] - pub fn uniform_matrix2fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform_matrix2fv(location.0, transpose, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform_matrix2fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniformMatrix3fv")] - pub fn uniform_matrix3fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform_matrix3fv(location.0, transpose, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform_matrix3fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "uniformMatrix4fv")] - pub fn uniform_matrix4fv(&self, location: ClassInstance, transpose: bool, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_uniform_matrix4fv(location.0, transpose, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_uniform_matrix4fv(location.0, transpose, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi] - pub fn use_program(&self, program: Option>) { - let program = program.map(|p| p.0).unwrap_or(0); - canvas_c::canvas_native_webgl_use_program(program, self.state) - } - - #[napi] - pub fn validate_program(&self, program: ClassInstance) { - canvas_c::canvas_native_webgl_validate_program(program.0, self.state) - } - - #[napi(js_name = "vertexAttrib1f")] - pub fn vertex_attrib1f(&self, index: u32, v0: f64) { - canvas_c::canvas_native_webgl_vertex_attrib1f(index, v0 as f32, self.state); - } - - #[napi(js_name = "vertexAttrib1fv")] - pub fn vertex_attrib1fv(&self, index: u32, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_vertex_attrib1fv(index, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_vertex_attrib1fv(index, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - - #[napi(js_name = "vertexAttrib2f")] - pub fn vertex_attrib2f(&self, index: u32, v0: f64, v1: f64) { - canvas_c::canvas_native_webgl_vertex_attrib2f(index, v0 as f32, v1 as f32, self.state); - } - - #[napi(js_name = "vertexAttrib2fv")] - pub fn vertex_attrib2fv(&self, index: u32, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_vertex_attrib2fv(index, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_vertex_attrib2fv(index, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "vertexAttrib3f")] - pub fn vertex_attrib3f(&self, index: u32, v0: f64, v1: f64, v2: f64) { - canvas_c::canvas_native_webgl_vertex_attrib3f(index, v0 as f32, v1 as f32, v2 as f32, self.state); - } - - #[napi(js_name = "vertexAttrib3fv")] - pub fn vertex_attrib3fv(&self, index: u32, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_vertex_attrib3fv(index, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_vertex_attrib3fv(index, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi(js_name = "vertexAttrib4f")] - pub fn vertex_attrib4f(&self, index: u32, v0: f64, v1: f64, v2: f64, v3: f64) { - canvas_c::canvas_native_webgl_vertex_attrib4f(index, v0 as f32, v1 as f32, v2 as f32, v3 as f32, self.state); - } - - #[napi(js_name = "vertexAttrib4fv")] - pub fn vertex_attrib4fv(&self, index: u32, value: Either, Float32Array>) { - match value { - Either::A(array) => { - let array = array.into_iter().map(|v| v as f32).collect::>(); - canvas_c::canvas_native_webgl_vertex_attrib4fv(index, array.as_ptr(), array.len(), self.state); - } - Either::B(buffer) => { - canvas_c::canvas_native_webgl_vertex_attrib4fv(index, buffer.as_ptr(), buffer.len(), self.state); - } - } - } - - #[napi( - ts_args_type = "index: number, size: number, type: number, normalized: boolean, stride: number, offset: number" - )] - pub fn vertex_attrib_pointer(&self, index: u32, size: i32, type_: u32, normalized: bool, stride: i32, offset: i64) { - canvas_c::canvas_native_webgl_vertex_attrib_pointer( - index, size, type_, normalized, stride, offset as isize, self.state, - ) - } - - #[napi] - pub fn viewport(&self, x: i32, y: i32, width: i32, height: i32) { - canvas_c::canvas_native_webgl_viewport(x, y, width, height, self.state); - } - - - #[napi(js_name = "toDataURL")] - pub fn to_data_url(&self, format: Option, encoderOptions: Option) -> String { - let c_str = CString::new(format.unwrap_or("image/png".to_string())).unwrap(); - let quality = encoderOptions - .map(|v| v as f32) - .unwrap_or(0.92) - .try_into() - .unwrap_or(0.92); - let quality: u32 = (quality * 100.) as u32; - let ret = canvas_c::canvas_native_webgl_to_data_url(self.state, c_str.as_ptr(), quality); - unsafe { CString::from_raw(ret as _).to_string_lossy().to_string() } - } - - #[napi(getter, js_name = "DEPTH_BUFFER_BIT")] - pub fn DEPTH_BUFFER_BIT(&self) -> u32 { 0x00000100 } - - #[napi(getter, js_name = "STENCIL_BUFFER_BIT")] - pub fn STENCIL_BUFFER_BIT(&self) -> u32 { 0x00000400 } - - #[napi(getter, js_name = "COLOR_BUFFER_BIT")] - pub fn COLOR_BUFFER_BIT(&self) -> u32 { 0x00004000 } - - #[napi(getter, js_name = "POINTS")] - pub fn POINTS(&self) -> u32 { 0x0000 } - - #[napi(getter, js_name = "LINES")] - pub fn LINES(&self) -> u32 { 0x0001 } - - #[napi(getter, js_name = "LINE_LOOP")] - pub fn LINE_LOOP(&self) -> u32 { 0x0002 } - - #[napi(getter, js_name = "LINE_STRIP")] - pub fn LINE_STRIP(&self) -> u32 { 0x0003 } - - #[napi(getter, js_name = "TRIANGLES")] - pub fn TRIANGLES(&self) -> u32 { 0x0004 } - - #[napi(getter, js_name = "TRIANGLE_STRIP")] - pub fn TRIANGLE_STRIP(&self) -> u32 { 0x0005 } - - #[napi(getter, js_name = "TRIANGLE_FAN")] - pub fn TRIANGLE_FAN(&self) -> u32 { 0x0006 } - - #[napi(getter, js_name = "ZERO")] - pub fn ZERO(&self) -> u32 { 0 } - - #[napi(getter, js_name = "ONE")] - pub fn ONE(&self) -> u32 { 1 } - - #[napi(getter, js_name = "SRC_COLOR")] - pub fn SRC_COLOR(&self) -> u32 { 0x0300 } - - #[napi(getter, js_name = "ONE_MINUS_SRC_COLOR")] - pub fn ONE_MINUS_SRC_COLOR(&self) -> u32 { 0x0301 } - - #[napi(getter, js_name = "SRC_ALPHA")] - pub fn SRC_ALPHA(&self) -> u32 { 0x0302 } - - #[napi(getter, js_name = "ONE_MINUS_SRC_ALPHA")] - pub fn ONE_MINUS_SRC_ALPHA(&self) -> u32 { 0x0303 } - - #[napi(getter, js_name = "DST_ALPHA")] - pub fn DST_ALPHA(&self) -> u32 { 0x0304 } - - #[napi(getter, js_name = "ONE_MINUS_DST_ALPHA")] - pub fn ONE_MINUS_DST_ALPHA(&self) -> u32 { 0x0305 } - - #[napi(getter, js_name = "DST_COLOR")] - pub fn DST_COLOR(&self) -> u32 { 0x0306 } - - #[napi(getter, js_name = "ONE_MINUS_DST_COLOR")] - pub fn ONE_MINUS_DST_COLOR(&self) -> u32 { 0x0307 } - - #[napi(getter, js_name = "SRC_ALPHA_SATURATE")] - pub fn SRC_ALPHA_SATURATE(&self) -> u32 { 0x0308 } - - #[napi(getter, js_name = "CONSTANT_COLOR")] - pub fn CONSTANT_COLOR(&self) -> u32 { 0x8001 } - - #[napi(getter, js_name = "ONE_MINUS_CONSTANT_COLOR")] - pub fn ONE_MINUS_CONSTANT_COLOR(&self) -> u32 { 0x8002 } - - #[napi(getter, js_name = "CONSTANT_ALPHA")] - pub fn CONSTANT_ALPHA(&self) -> u32 { 0x8003 } - - #[napi(getter, js_name = "ONE_MINUS_CONSTANT_ALPHA")] - pub fn ONE_MINUS_CONSTANT_ALPHA(&self) -> u32 { 0x8004 } - - /* Blending equations */ - #[napi(getter, js_name = "FUNC_ADD")] - pub fn FUNC_ADD(&self) -> u32 { 0x8006 } - - #[napi(getter, js_name = "FUNC_SUBTRACT")] - pub fn FUNC_SUBTRACT(&self) -> u32 { 0x800A } - - #[napi(getter, js_name = "FUNC_REVERSE_SUBTRACT")] - pub fn FUNC_REVERSE_SUBTRACT(&self) -> u32 { 0x800B } - - #[napi(getter, js_name = "BLEND_EQUATION")] - pub fn BLEND_EQUATION(&self) -> u32 { 0x8009 } - - #[napi(getter, js_name = "BLEND_EQUATION_RGB")] - pub fn BLEND_EQUATION_RGB(&self) -> u32 { 0x8009 } - - #[napi(getter, js_name = "BLEND_EQUATION_ALPHA")] - pub fn BLEND_EQUATION_ALPHA(&self) -> u32 { 0x883D } - - #[napi(getter, js_name = "BLEND_DST_RGB")] - pub fn BLEND_DST_RGB(&self) -> u32 { 0x80C8 } - - #[napi(getter, js_name = "BLEND_SRC_RGB")] - pub fn BLEND_SRC_RGB(&self) -> u32 { 0x80C9 } - - #[napi(getter, js_name = "BLEND_DST_ALPHA")] - pub fn BLEND_DST_ALPHA(&self) -> u32 { 0x80CA } - - #[napi(getter, js_name = "BLEND_SRC_ALPHA")] - pub fn BLEND_SRC_ALPHA(&self) -> u32 { 0x80CB } - - #[napi(getter, js_name = "BLEND_COLOR")] - pub fn BLEND_COLOR(&self) -> u32 { 0x8005 } - - #[napi(getter, js_name = "ARRAY_BUFFER_BINDING")] - pub fn ARRAY_BUFFER_BINDING(&self) -> u32 { 0x8894 } - - #[napi(getter, js_name = "ELEMENT_ARRAY_BUFFER_BINDING")] - pub fn ELEMENT_ARRAY_BUFFER_BINDING(&self) -> u32 { 0x8895 } - - #[napi(getter, js_name = "LINE_WIDTH")] - pub fn LINE_WIDTH(&self) -> u32 { 0x0B21 } - - #[napi(getter, js_name = "ALIASED_POINT_SIZE_RANGE")] - pub fn ALIASED_POINT_SIZE_RANGE(&self) -> u32 { 0x846D } - - #[napi(getter, js_name = "ALIASED_LINE_WIDTH_RANGE")] - pub fn ALIASED_LINE_WIDTH_RANGE(&self) -> u32 { 0x846E } - - #[napi(getter, js_name = "CULL_FACE_MODE")] - pub fn CULL_FACE_MODE(&self) -> u32 { 0x0B45 } - - #[napi(getter, js_name = "FRONT_FACE")] - pub fn FRONT_FACE(&self) -> u32 { 0x0B46 } - - #[napi(getter, js_name = "DEPTH_RANGE")] - pub fn DEPTH_RANGE(&self) -> u32 { 0x0B70 } - - #[napi(getter, js_name = "DEPTH_WRITEMASK")] - pub fn DEPTH_WRITEMASK(&self) -> u32 { 0x0B72 } - - #[napi(getter, js_name = "DEPTH_CLEAR_VALUE")] - pub fn DEPTH_CLEAR_VALUE(&self) -> u32 { 0x0B73 } - - #[napi(getter, js_name = "DEPTH_FUNC")] - pub fn DEPTH_FUNC(&self) -> u32 { 0x0B74 } - - #[napi(getter, js_name = "STENCIL_CLEAR_VALUE")] - pub fn STENCIL_CLEAR_VALUE(&self) -> u32 { 0x0B91 } - - #[napi(getter, js_name = "STENCIL_FUNC")] - pub fn STENCIL_FUNC(&self) -> u32 { 0x0B92 } - - #[napi(getter, js_name = "STENCIL_FAIL")] - pub fn STENCIL_FAIL(&self) -> u32 { 0x0B94 } - - #[napi(getter, js_name = "STENCIL_PASS_DEPTH_FAIL")] - pub fn STENCIL_PASS_DEPTH_FAIL(&self) -> u32 { 0x0B95 } - - #[napi(getter, js_name = "STENCIL_PASS_DEPTH_PASS")] - pub fn STENCIL_PASS_DEPTH_PASS(&self) -> u32 { 0x0B96 } - - #[napi(getter, js_name = "STENCIL_REF")] - pub fn STENCIL_REF(&self) -> u32 { 0x0B97 } - - #[napi(getter, js_name = "STENCIL_VALUE_MASK")] - pub fn STENCIL_VALUE_MASK(&self) -> u32 { 0x0B93 } - - #[napi(getter, js_name = "STENCIL_WRITEMASK")] - pub fn STENCIL_WRITEMASK(&self) -> u32 { 0x0B98 } - - #[napi(getter, js_name = "STENCIL_BACK_FUNC")] - pub fn STENCIL_BACK_FUNC(&self) -> u32 { 0x8800 } - - #[napi(getter, js_name = "STENCIL_BACK_FAIL")] - pub fn STENCIL_BACK_FAIL(&self) -> u32 { 0x8801 } - - #[napi(getter, js_name = "STENCIL_BACK_PASS_DEPTH_FAIL")] - pub fn STENCIL_BACK_PASS_DEPTH_FAIL(&self) -> u32 { 0x8802 } - - #[napi(getter, js_name = "STENCIL_BACK_PASS_DEPTH_PASS")] - pub fn STENCIL_BACK_PASS_DEPTH_PASS(&self) -> u32 { 0x8803 } - - #[napi(getter, js_name = "STENCIL_BACK_REF")] - pub fn STENCIL_BACK_REF(&self) -> u32 { 0x8CA3 } - - #[napi(getter, js_name = "STENCIL_BACK_VALUE_MASK")] - pub fn STENCIL_BACK_VALUE_MASK(&self) -> u32 { 0x8CA4 } - - #[napi(getter, js_name = "STENCIL_BACK_WRITEMASK")] - pub fn STENCIL_BACK_WRITEMASK(&self) -> u32 { 0x8CA5 } - - #[napi(getter, js_name = "VIEWPORT")] - pub fn VIEWPORT(&self) -> u32 { 0x0BA2 } - - #[napi(getter, js_name = "SCISSOR_BOX")] - pub fn SCISSOR_BOX(&self) -> u32 { 0x0C10 } - - #[napi(getter, js_name = "COLOR_CLEAR_VALUE")] - pub fn COLOR_CLEAR_VALUE(&self) -> u32 { 0x0C22 } - - #[napi(getter, js_name = "COLOR_WRITEMASK")] - pub fn COLOR_WRITEMASK(&self) -> u32 { 0x0C23 } - - #[napi(getter, js_name = "UNPACK_ALIGNMENT")] - pub fn UNPACK_ALIGNMENT(&self) -> u32 { 0x0CF5 } - - #[napi(getter, js_name = "PACK_ALIGNMENT")] - pub fn PACK_ALIGNMENT(&self) -> u32 { 0x0D05 } - - #[napi(getter, js_name = "MAX_TEXTURE_SIZE")] - pub fn MAX_TEXTURE_SIZE(&self) -> u32 { 0x0D33 } - - #[napi(getter, js_name = "MAX_VIEWPORT_DIMS")] - pub fn MAX_VIEWPORT_DIMS(&self) -> u32 { 0x0D3A } - - #[napi(getter, js_name = "SUBPIXEL_BITS")] - pub fn SUBPIXEL_BITS(&self) -> u32 { 0x0D50 } - - #[napi(getter, js_name = "RED_BITS")] - pub fn RED_BITS(&self) -> u32 { 0x0D52 } - - #[napi(getter, js_name = "GREEN_BITS")] - pub fn GREEN_BITS(&self) -> u32 { 0x0D53 } - - #[napi(getter, js_name = "BLUE_BITS")] - pub fn BLUE_BITS(&self) -> u32 { 0x0D54 } - - #[napi(getter, js_name = "ALPHA_BITS")] - pub fn ALPHA_BITS(&self) -> u32 { 0x0D55 } - - #[napi(getter, js_name = "DEPTH_BITS")] - pub fn DEPTH_BITS(&self) -> u32 { 0x0D56 } - - #[napi(getter, js_name = "STENCIL_BITS")] - pub fn STENCIL_BITS(&self) -> u32 { 0x0D57 } - - #[napi(getter, js_name = "POLYGON_OFFSET_UNITS")] - pub fn POLYGON_OFFSET_UNITS(&self) -> u32 { 0x2A00 } - - #[napi(getter, js_name = "POLYGON_OFFSET_FACTOR")] - pub fn POLYGON_OFFSET_FACTOR(&self) -> u32 { 0x8038 } - - #[napi(getter, js_name = "TEXTURE_BINDING_2D")] - pub fn TEXTURE_BINDING_2D(&self) -> u32 { 0x8069 } - - #[napi(getter, js_name = "SAMPLE_BUFFERS")] - pub fn SAMPLE_BUFFERS(&self) -> u32 { 0x80A8 } - - #[napi(getter, js_name = "SAMPLES")] - pub fn SAMPLES(&self) -> u32 { 0x80A9 } - - #[napi(getter, js_name = "SAMPLE_COVERAGE_VALUE")] - pub fn SAMPLE_COVERAGE_VALUE(&self) -> u32 { 0x80AA } - - #[napi(getter, js_name = "SAMPLE_COVERAGE_INVERT")] - pub fn SAMPLE_COVERAGE_INVERT(&self) -> u32 { 0x80AB } - - #[napi(getter, js_name = "COMPRESSED_TEXTURE_FORMATS")] - pub fn COMPRESSED_TEXTURE_FORMATS(&self) -> u32 { 0x86A3 } - - #[napi(getter, js_name = "VENDOR")] - pub fn VENDOR(&self) -> u32 { 0x1F00 } - - #[napi(getter, js_name = "RENDERER")] - pub fn RENDERER(&self) -> u32 { 0x1F01 } - - #[napi(getter, js_name = "VERSION")] - pub fn VERSION(&self) -> u32 { 0x1F02 } - - #[napi(getter, js_name = "IMPLEMENTATION_COLOR_READ_TYPE")] - pub fn IMPLEMENTATION_COLOR_READ_TYPE(&self) -> u32 { 0x8B9A } - - #[napi(getter, js_name = "IMPLEMENTATION_COLOR_READ_FORMAT")] - pub fn IMPLEMENTATION_COLOR_READ_FORMAT(&self) -> u32 { 0x8B9B } - - #[napi(getter, js_name = "BROWSER_DEFAULT_WEBGL")] - pub fn BROWSER_DEFAULT_WEBGL(&self) -> u32 { 0x9244 } - - #[napi(getter, js_name = "STATIC_DRAW")] - pub fn STATIC_DRAW(&self) -> u32 { 0x88E4 } - - #[napi(getter, js_name = "STREAM_DRAW")] - pub fn STREAM_DRAW(&self) -> u32 { 0x88E0 } - - #[napi(getter, js_name = "DYNAMIC_DRAW")] - pub fn DYNAMIC_DRAW(&self) -> u32 { 0x88E8 } - - #[napi(getter, js_name = "ARRAY_BUFFER")] - pub fn ARRAY_BUFFER(&self) -> u32 { 0x8892 } - - #[napi(getter, js_name = "ELEMENT_ARRAY_BUFFER")] - pub fn ELEMENT_ARRAY_BUFFER(&self) -> u32 { 0x8893 } - - #[napi(getter, js_name = "BUFFER_SIZE")] - pub fn BUFFER_SIZE(&self) -> u32 { 0x8764 } - - #[napi(getter, js_name = "BUFFER_USAGE")] - pub fn BUFFER_USAGE(&self) -> u32 { 0x8765 } - - #[napi(getter, js_name = "CURRENT_VERTEX_ATTRIB")] - pub fn CURRENT_VERTEX_ATTRIB(&self) -> u32 { 0x8626 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_ENABLED")] - pub fn VERTEX_ATTRIB_ARRAY_ENABLED(&self) -> u32 { 0x8622 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_SIZE")] - pub fn VERTEX_ATTRIB_ARRAY_SIZE(&self) -> u32 { 0x8623 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_STRIDE")] - pub fn VERTEX_ATTRIB_ARRAY_STRIDE(&self) -> u32 { 0x8624 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_TYPE")] - pub fn VERTEX_ATTRIB_ARRAY_TYPE(&self) -> u32 { 0x8625 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_NORMALIZED")] - pub fn VERTEX_ATTRIB_ARRAY_NORMALIZED(&self) -> u32 { 0x886A } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_POINTER")] - pub fn VERTEX_ATTRIB_ARRAY_POINTER(&self) -> u32 { 0x8645 } - - #[napi(getter, js_name = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")] - pub fn VERTEX_ATTRIB_ARRAY_BUFFER_BINDING(&self) -> u32 { 0x889F } - - #[napi(getter, js_name = "CULL_FACE")] - pub fn CULL_FACE(&self) -> u32 { 0x0B44 } - - #[napi(getter, js_name = "FRONT")] - pub fn FRONT(&self) -> u32 { 0x0404 } - - #[napi(getter, js_name = "BACK")] - pub fn BACK(&self) -> u32 { 0x0405 } - - #[napi(getter, js_name = "FRONT_AND_BACK")] - pub fn FRONT_AND_BACK(&self) -> u32 { 0x0408 } - - #[napi(getter, js_name = "BLEND")] - pub fn BLEND(&self) -> u32 { 0x0BE2 } - - #[napi(getter, js_name = "DEPTH_TEST")] - pub fn DEPTH_TEST(&self) -> u32 { 0x0B71 } - - #[napi(getter, js_name = "DITHER")] - pub fn DITHER(&self) -> u32 { 0x0BD0 } - - #[napi(getter, js_name = "POLYGON_OFFSET_FILL")] - pub fn POLYGON_OFFSET_FILL(&self) -> u32 { 0x8037 } - - #[napi(getter, js_name = "SAMPLE_ALPHA_TO_COVERAGE")] - pub fn SAMPLE_ALPHA_TO_COVERAGE(&self) -> u32 { 0x809E } - - #[napi(getter, js_name = "SAMPLE_COVERAGE")] - pub fn SAMPLE_COVERAGE(&self) -> u32 { 0x80A0 } - - #[napi(getter, js_name = "SCISSOR_TEST")] - pub fn SCISSOR_TEST(&self) -> u32 { 0x0C11 } - - #[napi(getter, js_name = "STENCIL_TEST")] - pub fn STENCIL_TEST(&self) -> u32 { 0x0B90 } - - /* Errors */ - #[napi(getter, js_name = "NO_ERROR")] - pub fn NO_ERROR(&self) -> u32 { 0 } - - #[napi(getter, js_name = "INVALID_ENUM")] - pub fn INVALID_ENUM(&self) -> u32 { 0x0500 } - - #[napi(getter, js_name = "INVALID_VALUE")] - pub fn INVALID_VALUE(&self) -> u32 { 0x0501 } - - #[napi(getter, js_name = "INVALID_OPERATION")] - pub fn INVALID_OPERATION(&self) -> u32 { 0x0502 } - - #[napi(getter, js_name = "OUT_OF_MEMORY")] - pub fn OUT_OF_MEMORY(&self) -> u32 { 0x0505 } - - #[napi(getter, js_name = "CONTEXT_LOST_WEBGL")] - pub fn CONTEXT_LOST_WEBGL(&self) -> u32 { 0x9242 } - - #[napi(getter, js_name = "CW")] - pub fn CW(&self) -> u32 { 0x0900 } - - #[napi(getter, js_name = "CCW")] - pub fn CCW(&self) -> u32 { 0x0901 } - - #[napi(getter, js_name = "DONT_CARE")] - pub fn DONT_CARE(&self) -> u32 { 0x1100 } - - #[napi(getter, js_name = "FASTEST")] - pub fn FASTEST(&self) -> u32 { 0x1101 } - - #[napi(getter, js_name = "NICEST")] - pub fn NICEST(&self) -> u32 { 0x1102 } - - #[napi(getter, js_name = "GENERATE_MIPMAP_HINT")] - pub fn GENERATE_MIPMAP_HINT(&self) -> u32 { 0x8192 } - - #[napi(getter, js_name = "BYTE")] - pub fn BYTE(&self) -> u32 { 0x1400 } - - #[napi(getter, js_name = "UNSIGNED_BYTE")] - pub fn UNSIGNED_BYTE(&self) -> u32 { 0x1401 } - - #[napi(getter, js_name = "SHORT")] - pub fn SHORT(&self) -> u32 { 0x1402 } - - #[napi(getter, js_name = "UNSIGNED_SHORT")] - pub fn UNSIGNED_SHORT(&self) -> u32 { 0x1403 } - - #[napi(getter, js_name = "INT")] - pub fn INT(&self) -> u32 { 0x1404 } - - #[napi(getter, js_name = "UNSIGNED_INT")] - pub fn UNSIGNED_INT(&self) -> u32 { 0x1405 } - - #[napi(getter, js_name = "FLOAT")] - pub fn FLOAT(&self) -> u32 { 0x1406 } - - #[napi(getter, js_name = "DEPTH_COMPONENT")] - pub fn DEPTH_COMPONENT(&self) -> u32 { 0x1902 } - - #[napi(getter, js_name = "ALPHA")] - pub fn ALPHA(&self) -> u32 { 0x1906 } - - #[napi(getter, js_name = "RGB")] - pub fn RGB(&self) -> u32 { 0x1907 } - - /* Clearing buffers */ - - #[napi(getter, js_name = "RGBA")] - pub fn RGBA(&self) -> u32 { 0x1908 } - - #[napi(getter, js_name = "LUMINANCE")] - pub fn LUMINANCE(&self) -> u32 { 0x1909 } - - #[napi(getter, js_name = "LUMINANCE_ALPHA")] - pub fn LUMINANCE_ALPHA(&self) -> u32 { 0x190A } - - /* Clearing buffers */ - - /* Rendering primitives */ - - #[napi(getter, js_name = "UNSIGNED_SHORT_4_4_4_4")] - pub fn UNSIGNED_SHORT_4_4_4_4(&self) -> u32 { 0x8033 } - - #[napi(getter, js_name = "UNSIGNED_SHORT_5_5_5_1")] - pub fn UNSIGNED_SHORT_5_5_5_1(&self) -> u32 { 0x8034 } - - #[napi(getter, js_name = "UNSIGNED_SHORT_5_6_5")] - pub fn UNSIGNED_SHORT_5_6_5(&self) -> u32 { 0x8363 } - - #[napi(getter, js_name = "FRAGMENT_SHADER")] - pub fn FRAGMENT_SHADER(&self) -> u32 { 0x8B30 } - - #[napi(getter, js_name = "VERTEX_SHADER")] - pub fn VERTEX_SHADER(&self) -> u32 { 0x8B31 } - - #[napi(getter, js_name = "COMPILE_STATUS")] - pub fn COMPILE_STATUS(&self) -> u32 { 0x8B81 } - - #[napi(getter, js_name = "DELETE_STATUS")] - pub fn DELETE_STATUS(&self) -> u32 { 0x8B80 } - - /* Rendering primitives */ - - /* Blending modes */ - - #[napi(getter, js_name = "LINK_STATUS")] - pub fn LINK_STATUS(&self) -> u32 { 0x8B82 } - - #[napi(getter, js_name = "VALIDATE_STATUS")] - pub fn VALIDATE_STATUS(&self) -> u32 { 0x8B83 } - - #[napi(getter, js_name = "ATTACHED_SHADERS")] - pub fn ATTACHED_SHADERS(&self) -> u32 { 0x8B85 } - - #[napi(getter, js_name = "ACTIVE_ATTRIBUTES")] - pub fn ACTIVE_ATTRIBUTES(&self) -> u32 { 0x8B89 } - - #[napi(getter, js_name = "ACTIVE_UNIFORMS")] - pub fn ACTIVE_UNIFORMS(&self) -> u32 { 0x8B86 } - - #[napi(getter, js_name = "MAX_VERTEX_ATTRIBS")] - pub fn MAX_VERTEX_ATTRIBS(&self) -> u32 { 0x8869 } - - #[napi(getter, js_name = "MAX_VERTEX_UNIFORM_VECTORS")] - pub fn MAX_VERTEX_UNIFORM_VECTORS(&self) -> u32 { 0x8DFB } - - #[napi(getter, js_name = "MAX_VARYING_VECTORS")] - pub fn MAX_VARYING_VECTORS(&self) -> u32 { 0x8DFC } - - #[napi(getter, js_name = "MAX_COMBINED_TEXTURE_IMAGE_UNITS")] - pub fn MAX_COMBINED_TEXTURE_IMAGE_UNITS(&self) -> u32 { 0x8B4D } - - #[napi(getter, js_name = "MAX_VERTEX_TEXTURE_IMAGE_UNITS")] - pub fn MAX_VERTEX_TEXTURE_IMAGE_UNITS(&self) -> u32 { 0x8B4C } - - #[napi(getter, js_name = "MAX_TEXTURE_IMAGE_UNITS")] - pub fn MAX_TEXTURE_IMAGE_UNITS(&self) -> u32 { 0x8872 } - - #[napi(getter, js_name = "MAX_FRAGMENT_UNIFORM_VECTORS")] - pub fn MAX_FRAGMENT_UNIFORM_VECTORS(&self) -> u32 { 0x8DFD } - - #[napi(getter, js_name = "SHADER_TYPE")] - pub fn SHADER_TYPE(&self) -> u32 { 0x8B4F } - - #[napi(getter, js_name = "SHADING_LANGUAGE_VERSION")] - pub fn SHADING_LANGUAGE_VERSION(&self) -> u32 { 0x8B8C } - - #[napi(getter, js_name = "CURRENT_PROGRAM")] - pub fn CURRENT_PROGRAM(&self) -> u32 { 0x8B8D } - - /* Blending modes */ - - #[napi(getter, js_name = "NEVER")] - pub fn NEVER(&self) -> u32 { 0x0200 } - - #[napi(getter, js_name = "LESS")] - pub fn LESS(&self) -> u32 { 0x0201 } - - #[napi(getter, js_name = "EQUAL")] - pub fn EQUAL(&self) -> u32 { 0x0202 } - - /* Blending equations */ - - /* Getting GL parameter information */ - - #[napi(getter, js_name = "LEQUAL")] - pub fn LEQUAL(&self) -> u32 { 0x0203 } - - #[napi(getter, js_name = "GREATER")] - pub fn GREATER(&self) -> u32 { 0x0204 } - - #[napi(getter, js_name = "NOTEQUAL")] - pub fn NOTEQUAL(&self) -> u32 { 0x0205 } - - #[napi(getter, js_name = "GEQUAL")] - pub fn GEQUAL(&self) -> u32 { 0x0206 } - - #[napi(getter, js_name = "ALWAYS")] - pub fn ALWAYS(&self) -> u32 { 0x0207 } - - #[napi(getter, js_name = "KEEP")] - pub fn KEEP(&self) -> u32 { 0x1E00 } - - #[napi(getter, js_name = "REPLACE")] - pub fn REPLACE(&self) -> u32 { 0x1E01 } - - #[napi(getter, js_name = "INCR")] - pub fn INCR(&self) -> u32 { 0x1E02 } - - #[napi(getter, js_name = "DECR")] - pub fn DECR(&self) -> u32 { 0x1E03 } - - #[napi(getter, js_name = "INVERT")] - pub fn INVERT(&self) -> u32 { 0x150A } - - #[napi(getter, js_name = "INCR_WRAP")] - pub fn INCR_WRAP(&self) -> u32 { 0x8507 } - - #[napi(getter, js_name = "DECR_WRAP")] - pub fn DECR_WRAP(&self) -> u32 { 0x8508 } - - #[napi(getter, js_name = "NEAREST")] - pub fn NEAREST(&self) -> u32 { 0x2600 } - - #[napi(getter, js_name = "LINEAR")] - pub fn LINEAR(&self) -> u32 { 0x2601 } - - #[napi(getter, js_name = "NEAREST_MIPMAP_NEAREST")] - pub fn NEAREST_MIPMAP_NEAREST(&self) -> u32 { 0x2700 } - - #[napi(getter, js_name = "LINEAR_MIPMAP_NEAREST")] - pub fn LINEAR_MIPMAP_NEAREST(&self) -> u32 { 0x2701 } - - #[napi(getter, js_name = "NEAREST_MIPMAP_LINEAR")] - pub fn NEAREST_MIPMAP_LINEAR(&self) -> u32 { 0x2702 } - - #[napi(getter, js_name = "LINEAR_MIPMAP_LINEAR")] - pub fn LINEAR_MIPMAP_LINEAR(&self) -> u32 { 0x2703 } - - #[napi(getter, js_name = "TEXTURE_MAG_FILTER")] - pub fn TEXTURE_MAG_FILTER(&self) -> u32 { 0x2800 } - - #[napi(getter, js_name = "TEXTURE_MIN_FILTER")] - pub fn TEXTURE_MIN_FILTER(&self) -> u32 { 0x2801 } - - #[napi(getter, js_name = "TEXTURE_WRAP_S")] - pub fn TEXTURE_WRAP_S(&self) -> u32 { 0x2802 } - - #[napi(getter, js_name = "TEXTURE_WRAP_T")] - pub fn TEXTURE_WRAP_T(&self) -> u32 { 0x2803 } - - #[napi(getter, js_name = "TEXTURE_2D")] - pub fn TEXTURE_2D(&self) -> u32 { 0x0DE1 } - - #[napi(getter, js_name = "TEXTURE")] - pub fn TEXTURE(&self) -> u32 { 0x1702 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP")] - pub fn TEXTURE_CUBE_MAP(&self) -> u32 { 0x8513 } - - #[napi(getter, js_name = "TEXTURE_BINDING_CUBE_MAP")] - pub fn TEXTURE_BINDING_CUBE_MAP(&self) -> u32 { 0x8514 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_X")] - pub fn TEXTURE_CUBE_MAP_POSITIVE_X(&self) -> u32 { 0x8515 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_X")] - pub fn TEXTURE_CUBE_MAP_NEGATIVE_X(&self) -> u32 { 0x8516 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_Y")] - pub fn TEXTURE_CUBE_MAP_POSITIVE_Y(&self) -> u32 { 0x8517 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_Y")] - pub fn TEXTURE_CUBE_MAP_NEGATIVE_Y(&self) -> u32 { 0x8518 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_POSITIVE_Z")] - pub fn TEXTURE_CUBE_MAP_POSITIVE_Z(&self) -> u32 { 0x8519 } - - #[napi(getter, js_name = "TEXTURE_CUBE_MAP_NEGATIVE_Z")] - pub fn TEXTURE_CUBE_MAP_NEGATIVE_Z(&self) -> u32 { 0x851A } - - #[napi(getter, js_name = "MAX_CUBE_MAP_TEXTURE_SIZE")] - pub fn MAX_CUBE_MAP_TEXTURE_SIZE(&self) -> u32 { 0x851C } - - #[napi(getter, js_name = "TEXTURE0")] - pub fn TEXTURE0(&self) -> u32 { 0x84C0 } - - #[napi(getter, js_name = "TEXTURE1")] - pub fn TEXTURE1(&self) -> u32 { 0x84C1 } - - #[napi(getter, js_name = "TEXTURE2")] - pub fn TEXTURE2(&self) -> u32 { 0x84C2 } - - #[napi(getter, js_name = "TEXTURE3")] - pub fn TEXTURE3(&self) -> u32 { 0x84C3 } - - #[napi(getter, js_name = "TEXTURE4")] - pub fn TEXTURE4(&self) -> u32 { 0x84C4 } - - #[napi(getter, js_name = "TEXTURE5")] - pub fn TEXTURE5(&self) -> u32 { 0x84C5 } - - #[napi(getter, js_name = "TEXTURE6")] - pub fn TEXTURE6(&self) -> u32 { 0x84C6 } - - #[napi(getter, js_name = "TEXTURE7")] - pub fn TEXTURE7(&self) -> u32 { 0x84C7 } - - #[napi(getter, js_name = "TEXTURE8")] - pub fn TEXTURE8(&self) -> u32 { 0x84C8 } - - #[napi(getter, js_name = "TEXTURE9")] - pub fn TEXTURE9(&self) -> u32 { 0x84C9 } - - #[napi(getter, js_name = "TEXTURE10")] - pub fn TEXTURE10(&self) -> u32 { 0x84CA } - - #[napi(getter, js_name = "TEXTURE11")] - pub fn TEXTURE11(&self) -> u32 { 0x84CB } - - #[napi(getter, js_name = "TEXTURE12")] - pub fn TEXTURE12(&self) -> u32 { 0x84CC } - - #[napi(getter, js_name = "TEXTURE13")] - pub fn TEXTURE13(&self) -> u32 { 0x84CD } - - #[napi(getter, js_name = "TEXTURE14")] - pub fn TEXTURE14(&self) -> u32 { 0x84CE } - - #[napi(getter, js_name = "TEXTURE15")] - pub fn TEXTURE15(&self) -> u32 { 0x84CF } - - #[napi(getter, js_name = "TEXTURE16")] - pub fn TEXTURE16(&self) -> u32 { 0x84D0 } - - #[napi(getter, js_name = "TEXTURE17")] - pub fn TEXTURE17(&self) -> u32 { 0x84D1 } - - #[napi(getter, js_name = "TEXTURE18")] - pub fn TEXTURE18(&self) -> u32 { 0x84D2 } - - #[napi(getter, js_name = "TEXTURE19")] - pub fn TEXTURE19(&self) -> u32 { 0x84D3 } - - #[napi(getter, js_name = "TEXTURE20")] - pub fn TEXTURE20(&self) -> u32 { 0x84D4 } - - #[napi(getter, js_name = "TEXTURE21")] - pub fn TEXTURE21(&self) -> u32 { 0x84D5 } - - #[napi(getter, js_name = "TEXTURE22")] - pub fn TEXTURE22(&self) -> u32 { 0x84D6 } - - #[napi(getter, js_name = "TEXTURE23")] - pub fn TEXTURE23(&self) -> u32 { 0x84D7 } - - #[napi(getter, js_name = "TEXTURE24")] - pub fn TEXTURE24(&self) -> u32 { 0x84D8 } - - #[napi(getter, js_name = "TEXTURE25")] - pub fn TEXTURE25(&self) -> u32 { 0x84D9 } - - #[napi(getter, js_name = "TEXTURE26")] - pub fn TEXTURE26(&self) -> u32 { 0x84DA } - - #[napi(getter, js_name = "TEXTURE27")] - pub fn TEXTURE27(&self) -> u32 { 0x84DB } - - #[napi(getter, js_name = "TEXTURE28")] - pub fn TEXTURE28(&self) -> u32 { 0x84DC } - - #[napi(getter, js_name = "TEXTURE29")] - pub fn TEXTURE29(&self) -> u32 { 0x84DD } - - /* Getting GL parameter information */ - - /* Buffers */ - - #[napi(getter, js_name = "TEXTURE30")] - pub fn TEXTURE30(&self) -> u32 { 0x84DE } - - #[napi(getter, js_name = "TEXTURE31")] - pub fn TEXTURE31(&self) -> u32 { 0x84DF } - - #[napi(getter, js_name = "ACTIVE_TEXTURE")] - pub fn ACTIVE_TEXTURE(&self) -> u32 { 0x84E0 } - - #[napi(getter, js_name = "REPEAT")] - pub fn REPEAT(&self) -> u32 { 0x2901 } - - #[napi(getter, js_name = "CLAMP_TO_EDGE")] - pub fn CLAMP_TO_EDGE(&self) -> u32 { 0x812F } - - #[napi(getter, js_name = "MIRRORED_REPEAT")] - pub fn MIRRORED_REPEAT(&self) -> u32 { 0x8370 } - - #[napi(getter, js_name = "FLOAT_VEC2")] - pub fn FLOAT_VEC2(&self) -> u32 { 0x8B50 } - - /* Buffers */ - - /* Vertex attributes */ - - #[napi(getter, js_name = "FLOAT_VEC3")] - pub fn FLOAT_VEC3(&self) -> u32 { 0x8B51 } - - #[napi(getter, js_name = "FLOAT_VEC4")] - pub fn FLOAT_VEC4(&self) -> u32 { 0x8B52 } - - #[napi(getter, js_name = "INT_VEC2")] - pub fn INT_VEC2(&self) -> u32 { 0x8B53 } - - #[napi(getter, js_name = "INT_VEC3")] - pub fn INT_VEC3(&self) -> u32 { 0x8B54 } - - #[napi(getter, js_name = "INT_VEC4")] - pub fn INT_VEC4(&self) -> u32 { 0x8B55 } - - #[napi(getter, js_name = "BOOL")] - pub fn BOOL(&self) -> u32 { 0x8B56 } - - #[napi(getter, js_name = "BOOL_VEC2")] - pub fn BOOL_VEC2(&self) -> u32 { 0x8B57 } - - #[napi(getter, js_name = "BOOL_VEC3")] - pub fn BOOL_VEC3(&self) -> u32 { 0x8B58 } - - /* Vertex attributes */ - - /* Culling */ - - #[napi(getter, js_name = "BOOL_VEC4")] - pub fn BOOL_VEC4(&self) -> u32 { 0x8B59 } - - #[napi(getter, js_name = "FLOAT_MAT2")] - pub fn FLOAT_MAT2(&self) -> u32 { 0x8B5A } - - #[napi(getter, js_name = "FLOAT_MAT3")] - pub fn FLOAT_MAT3(&self) -> u32 { 0x8B5B } - - #[napi(getter, js_name = "FLOAT_MAT4")] - pub fn FLOAT_MAT4(&self) -> u32 { 0x8B5C } - - /* Culling */ - - /* Enabling and disabling */ - - #[napi(getter, js_name = "SAMPLER_2D")] - pub fn SAMPLER_2D(&self) -> u32 { 0x8B5E } - - #[napi(getter, js_name = "SAMPLER_CUBE")] - pub fn SAMPLER_CUBE(&self) -> u32 { 0x8B60 } - - #[napi(getter, js_name = "LOW_FLOAT")] - pub fn LOW_FLOAT(&self) -> u32 { 0x8DF0 } - - #[napi(getter, js_name = "MEDIUM_FLOAT")] - pub fn MEDIUM_FLOAT(&self) -> u32 { 0x8DF1 } - - #[napi(getter, js_name = "HIGH_FLOAT")] - pub fn HIGH_FLOAT(&self) -> u32 { 0x8DF2 } - - #[napi(getter, js_name = "LOW_INT")] - pub fn LOW_INT(&self) -> u32 { 0x8DF3 } - - #[napi(getter, js_name = "MEDIUM_INT")] - pub fn MEDIUM_INT(&self) -> u32 { 0x8DF4 } - - #[napi(getter, js_name = "HIGH_INT")] - pub fn HIGH_INT(&self) -> u32 { 0x8DF5 } - - /* Enabling and disabling */ - - #[napi(getter, js_name = "FRAMEBUFFER")] - pub fn FRAMEBUFFER(&self) -> u32 { 0x8D40 } - - #[napi(getter, js_name = "RENDERBUFFER")] - pub fn RENDERBUFFER(&self) -> u32 { 0x8D41 } - - #[napi(getter, js_name = "RGBA4")] - pub fn RGBA4(&self) -> u32 { 0x8056 } - - #[napi(getter, js_name = "RGB5_A1")] - pub fn RGB5_A1(&self) -> u32 { 0x8057 } - - #[napi(getter, js_name = "RGB565")] - pub fn RGB565(&self) -> u32 { 0x8D62 } - - #[napi(getter, js_name = "DEPTH_COMPONENT16")] - pub fn DEPTH_COMPONENT16(&self) -> u32 { 0x81A5 } - - #[napi(getter, js_name = "STENCIL_INDEX8")] - pub fn STENCIL_INDEX8(&self) -> u32 { 0x8D48 } - - /* Errors */ - - /* Front face directions */ - - #[napi(getter, js_name = "DEPTH_STENCIL")] - pub fn DEPTH_STENCIL(&self) -> u32 { 0x84F9 } - - #[napi(getter, js_name = "RENDERBUFFER_WIDTH")] - pub fn RENDERBUFFER_WIDTH(&self) -> u32 { 0x8D42 } - - /* Front face directions */ - - /* Hints */ - - #[napi(getter, js_name = "RENDERBUFFER_HEIGHT")] - pub fn RENDERBUFFER_HEIGHT(&self) -> u32 { 0x8D43 } - - #[napi(getter, js_name = "RENDERBUFFER_INTERNAL_FORMAT")] - pub fn RENDERBUFFER_INTERNAL_FORMAT(&self) -> u32 { 0x8D44 } - - #[napi(getter, js_name = "RENDERBUFFER_RED_SIZE")] - pub fn RENDERBUFFER_RED_SIZE(&self) -> u32 { 0x8D50 } - - #[napi(getter, js_name = "RENDERBUFFER_GREEN_SIZE")] - pub fn RENDERBUFFER_GREEN_SIZE(&self) -> u32 { 0x8D51 } - - /* Hints */ - - /* Data types */ - - #[napi(getter, js_name = "RENDERBUFFER_BLUE_SIZE")] - pub fn RENDERBUFFER_BLUE_SIZE(&self) -> u32 { 0x8D52 } - - #[napi(getter, js_name = "RENDERBUFFER_ALPHA_SIZE")] - pub fn RENDERBUFFER_ALPHA_SIZE(&self) -> u32 { 0x8D53 } - - #[napi(getter, js_name = "RENDERBUFFER_DEPTH_SIZE")] - pub fn RENDERBUFFER_DEPTH_SIZE(&self) -> u32 { 0x8D54 } - - #[napi(getter, js_name = "RENDERBUFFER_STENCIL_SIZE")] - pub fn RENDERBUFFER_STENCIL_SIZE(&self) -> u32 { 0x8D55 } - - #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE")] - pub fn FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE(&self) -> u32 { 0x8CD0 } - - #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME")] - pub fn FRAMEBUFFER_ATTACHMENT_OBJECT_NAME(&self) -> u32 { 0x8CD1 } - - #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL")] - pub fn FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL(&self) -> u32 { 0x8CD2 } - - /* Data types */ - - /* Pixel formats */ - - #[napi(getter, js_name = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE")] - pub fn FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE(&self) -> u32 { 0x8CD3 } - - #[napi(getter, js_name = "COLOR_ATTACHMENT0")] - pub fn COLOR_ATTACHMENT0(&self) -> u32 { 0x8CE0 } - - #[napi(getter, js_name = "DEPTH_ATTACHMENT")] - pub fn DEPTH_ATTACHMENT(&self) -> u32 { 0x8D00 } - - #[napi(getter, js_name = "STENCIL_ATTACHMENT")] - pub fn STENCIL_ATTACHMENT(&self) -> u32 { 0x8D20 } - - #[napi(getter, js_name = "DEPTH_STENCIL_ATTACHMENT")] - pub fn DEPTH_STENCIL_ATTACHMENT(&self) -> u32 { 0x821A } - - #[napi(getter, js_name = "NONE")] - pub fn NONE(&self) -> u32 { 0 } - - /* Pixel formats */ - - /* Pixel types */ - - // #[napi(getter, js_name = "UNSIGNED_BYTE")] - // pub fn UNSIGNED_BYTE(&self) -> u32 { return UNSIGNED_BYTE} - - #[napi(getter, js_name = "FRAMEBUFFER_COMPLETE")] - pub fn FRAMEBUFFER_COMPLETE(&self) -> u32 { 0x8CD5 } - - #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT")] - pub fn FRAMEBUFFER_INCOMPLETE_ATTACHMENT(&self) -> u32 { 0x8CD6 } - - #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT")] - pub fn FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT(&self) -> u32 { 0x8CD7 } - - /* Pixel types */ - - /* Shaders */ - - #[napi(getter, js_name = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS")] - pub fn FRAMEBUFFER_INCOMPLETE_DIMENSIONS(&self) -> u32 { 0x8CD9 } - - #[napi(getter, js_name = "FRAMEBUFFER_UNSUPPORTED")] - pub fn FRAMEBUFFER_UNSUPPORTED(&self) -> u32 { 0x8CDD } - - #[napi(getter, js_name = "FRAMEBUFFER_BINDING")] - pub fn FRAMEBUFFER_BINDING(&self) -> u32 { 0x8CA6 } - - #[napi(getter, js_name = "RENDERBUFFER_BINDING")] - pub fn RENDERBUFFER_BINDING(&self) -> u32 { 0x8CA7 } - - #[napi(getter, js_name = "MAX_RENDERBUFFER_SIZE")] - pub fn MAX_RENDERBUFFER_SIZE(&self) -> u32 { 0x84E8 } - - #[napi(getter, js_name = "INVALID_FRAMEBUFFER_OPERATION")] - pub fn INVALID_FRAMEBUFFER_OPERATION(&self) -> u32 { 0x0506 } - - #[napi(getter, js_name = "UNPACK_FLIP_Y_WEBGL")] - pub fn UNPACK_FLIP_Y_WEBGL(&self) -> u32 { 0x9240 } - - #[napi(getter, js_name = "UNPACK_PREMULTIPLY_ALPHA_WEBGL")] - pub fn UNPACK_PREMULTIPLY_ALPHA_WEBGL(&self) -> u32 { 0x9241 } - #[napi(getter, js_name = "UNPACK_COLORSPACE_CONVERSION_WEBGL")] - pub fn UNPACK_COLORSPACE_CONVERSION_WEBGL(&self) -> u32 { 0x9243 } -} \ No newline at end of file +impl_webgl_context_constants!(web_g_l_rendering_context); \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2.rs b/napi/canvas-napi/src/gl2.rs deleted file mode 100644 index 72b5d56ac..000000000 --- a/napi/canvas-napi/src/gl2.rs +++ /dev/null @@ -1,14 +0,0 @@ -use napi::bindgen_prelude::ObjectFinalize; -use napi::Env; - -#[napi(custom_finalize)] -pub struct web_g_l_2_rendering_context { - state: *mut canvas_c::WebGLState, -} - -impl ObjectFinalize for web_g_l_2_rendering_context { - fn finalize(self, _: Env) -> napi::Result<()> { - canvas_c::canvas_native_webgl_state_destroy(self.state); - Ok(()) - } -} \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2/mod.rs b/napi/canvas-napi/src/gl2/mod.rs new file mode 100644 index 000000000..612b60e86 --- /dev/null +++ b/napi/canvas-napi/src/gl2/mod.rs @@ -0,0 +1,1096 @@ +pub mod webgl_query; +pub mod webgl_sampler; +pub mod webgl_transform_feedback; +pub mod webgl_vertex_array_object; +pub mod webgl_sync; + +use napi::*; +use napi_derive::napi; +use std::ops::Deref; + +use crate::gl::*; + +use crate::gl2::webgl_query::WebGLQuery; +use crate::gl2::webgl_sampler::WebGLSampler; +use crate::gl2::webgl_sync::WebGLSync; +use crate::gl2::webgl_transform_feedback::WebGLTransformFeedback; +use crate::gl2::webgl_vertex_array_object::WebGLVertexArrayObject; +use napi::{Either, Env}; + +use crate::{impl_webgl2_context_constants, impl_webgl_context, impl_webgl_context_constants}; + +#[napi(custom_finalize)] +pub struct web_g_l_2_rendering_context { + state: *mut WebGLState, +} + +impl_webgl_context!(web_g_l_2_rendering_context); + +impl ObjectFinalize for web_g_l_2_rendering_context { + fn finalize(self, _: Env) -> napi::Result<()> { + canvas_c::canvas_native_webgl_state_destroy(self.state); + Ok(()) + } +} + +#[napi] +impl web_g_l_2_rendering_context { + #[napi(factory)] + pub fn with_view( + view: i64, + alpha: bool, + antialias: bool, + depth: bool, + fail_if_major_performance_caveat: bool, + power_preference: i32, + premultiplied_alpha: bool, + preserve_drawing_buffer: bool, + stencil: bool, + desynchronized: bool, + xr_compatible: bool, + ) -> Result { + let ret = canvas_c::canvas_native_webgl_create( + view as _, + 2, + alpha, + antialias, + depth, + fail_if_major_performance_caveat, + power_preference, + premultiplied_alpha, + preserve_drawing_buffer, + stencil, + desynchronized, + xr_compatible, + ); + + if ret.is_null() { + return Err(napi::Error::from_reason("Invalid parameter")); + } + + Ok(web_g_l_2_rendering_context { + state: ret + }) + } + + #[napi(factory)] + pub fn offscreen( + width: i32, + height: i32, + alpha: bool, + antialias: bool, + depth: bool, + fail_if_major_performance_caveat: bool, + power_preference: i32, + premultiplied_alpha: bool, + preserve_drawing_buffer: bool, + stencil: bool, + desynchronized: bool, + xr_compatible: bool, + is_canvas: bool, + ) -> Result { + let ret = canvas_c::canvas_native_webgl_create_no_window( + width, + height, + 2, + alpha, + antialias, + depth, + fail_if_major_performance_caveat, + power_preference, + premultiplied_alpha, + preserve_drawing_buffer, + stencil, + desynchronized, + xr_compatible, + is_canvas, + ); + + if ret.is_null() { + return Err(napi::Error::from_reason("Invalid parameter")); + } + + Ok(web_g_l_2_rendering_context { + state: ret + }) + } + + + /* Transform feedback */ + + #[napi] + pub fn begin_query(&self, target: u32, query: ClassInstance) { + canvas_c::canvas_native_webgl2_begin_query(target, query.0, self.state); + } + + #[napi] + pub fn begin_transform_feedback(&self, primitive_mode: u32) { + canvas_c::canvas_native_webgl2_begin_transform_feedback(primitive_mode, self.state); + } + + #[napi] + pub fn bind_buffer_base(&self, target: u32, index: u32, buffer: ClassInstance) { + canvas_c::canvas_native_webgl2_bind_buffer_base(target, index, buffer.0, self.state); + } + + #[napi] + pub fn bind_buffer_range(&self, target: u32, index: u32, buffer: ClassInstance, offset: i64, size: i64) { + canvas_c::canvas_native_webgl2_bind_buffer_range(target, index, buffer.0, offset as isize, size as isize, self.state); + } + + #[napi] + pub fn bind_sampler(&self, unit: u32, sampler: ClassInstance) { + canvas_c::canvas_native_webgl2_bind_sampler(unit, sampler.0, self.state); + } + + #[napi] + pub fn bind_transform_feedback(&self, target: u32, transform_feedback: &WebGLTransformFeedback) { + canvas_c::canvas_native_webgl2_bind_transform_feedback(target, transform_feedback.0, self.state); + } + + #[napi] + pub fn bind_vertex_array(&self, vertex_array: &WebGLVertexArrayObject) { + canvas_c::canvas_native_webgl2_bind_vertex_array(vertex_array.0, self.state); + } + + #[napi] + pub fn blit_framebuffer(&self, src_x0: i32, src_y0: i32, src_x1: i32, src_y1: i32, dst_x0: i32, dst_y0: i32, dst_x1: i32, dst_y1: i32, mask: u32, filter: u32) { + canvas_c::canvas_native_webgl2_blit_framebuffer(src_x0, src_y0, src_x1, src_y1, dst_x0, dst_y0, dst_x1, dst_y1, mask, filter, self.state); + } + + #[napi] + pub fn clear_bufferfi(&self, buffer: ClassInstance, drawbuffer: i32, depth: f64, stencil: i32) { + canvas_c::canvas_native_webgl2_clear_bufferfi(buffer.0, drawbuffer, depth as f32, stencil, self.state); + } + + #[napi] + pub fn clear_bufferfv(&self, buffer: ClassInstance, drawbuffer: i32, values: Either, Float32Array>) { + match values { + Either::A(array) => { + let array = array.into_iter().map(|v| v as f32).collect::>(); + canvas_c::canvas_native_webgl2_clear_bufferfv(buffer.0, drawbuffer, array.as_ptr(), array.len(), self.state) + } + Either::B(value) => { + canvas_c::canvas_native_webgl2_clear_bufferfv(buffer.0, drawbuffer, value.as_ptr(), value.len(), self.state) + } + } + } + + + #[napi] + pub fn clear_bufferiv(&self, buffer: ClassInstance, drawbuffer: i32, values: Either, Int32Array>) { + match values { + Either::A(array) => { + canvas_c::canvas_native_webgl2_clear_bufferiv(buffer.0, drawbuffer, array.as_ptr(), array.len(), self.state) + } + Either::B(value) => { + canvas_c::canvas_native_webgl2_clear_bufferiv(buffer.0, drawbuffer, value.as_ptr(), value.len(), self.state) + } + } + } + + #[napi] + pub fn clear_bufferuiv(&self, buffer: ClassInstance, drawbuffer: i32, values: Either, Uint32Array>) { + match values { + Either::A(array) => { + canvas_c::canvas_native_webgl2_clear_bufferuiv(buffer.0, drawbuffer, array.as_ptr(), array.len(), self.state) + } + Either::B(value) => { + canvas_c::canvas_native_webgl2_clear_bufferuiv(buffer.0, drawbuffer, value.as_ptr(), value.len(), self.state) + } + } + } + + #[napi] + pub fn client_wait_sync(&self, sync: &WebGLSync, flags: u32, timeout: i64) -> u32 { + canvas_c::canvas_native_webgl2_client_wait_sync(sync.0, flags, timeout as isize, self.state) + } + + #[napi] + pub fn compressed_tex_image_3_d(&self, target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, image_size_or_src_data: Either, src_offset: Option, src_length_override: Option) { + match image_size_or_src_data { + Either::A(size) => { + canvas_c::canvas_native_webgl2_compressed_tex_image3d_none(target, level, internalformat, width, height, depth, border, size, src_offset.unwrap_or_default() as usize, self.state) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_compressed_tex_image3d(target, level, internalformat, width, height, depth, border, buffer.as_ptr(), buffer.len(), src_offset.unwrap_or_default() as usize, src_length_override.unwrap_or_default() as usize, self.state) + } + } + } + + #[napi] + pub fn compressed_tex_sub_image_3_d(&self, target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, image_size_or_src_data: Either, src_offset: Option, src_length_override: Option) { + match image_size_or_src_data { + Either::A(size) => { + canvas_c::canvas_native_webgl2_compressed_tex_sub_image3d_none( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, size, src_offset.unwrap_or_default() as usize, self.state, + ) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_compressed_tex_sub_image3d( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, buffer.as_ptr(), buffer.len(), src_offset.unwrap_or_default() as usize, src_length_override.unwrap_or_default() as usize, self.state, + ) + } + } + } + + /* Transform feedback */ + + /* Framebuffers and renderbuffers */ + + + #[napi] + pub fn copy_buffer_sub_data(&self, read_target: u32, write_target: u32, read_offset: i64, write_offset: i64, size: i64) { + canvas_c::canvas_native_webgl2_copy_buffer_sub_data(read_target, write_target, read_offset as isize, write_offset as isize, size as isize, self.state) + } + + #[napi] + pub fn copy_tex_sub_image_3_d(&self, target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32) { + canvas_c::canvas_native_webgl2_copy_tex_sub_image3d(target, level, xoffset, yoffset, zoffset, x, y, width, height, self.state); + } + + #[napi] + pub fn create_query(&self, env: Env) -> Result> { + WebGLQuery( + canvas_c::canvas_native_webgl2_create_query(self.state) + ).into_instance(env) + } + + + #[napi] + pub fn create_sampler(&self, env: Env) -> Result> { + WebGLSampler( + canvas_c::canvas_native_webgl2_create_sampler(self.state) + ).into_instance(env) + } + + #[napi] + pub fn create_transform_feedback(&self, env: Env) -> Result> { + WebGLTransformFeedback( + canvas_c::canvas_native_webgl2_create_transform_feedback(self.state) + ).into_instance(env) + } + + #[napi] + pub fn create_vertex_array(&self, env: Env) -> Result> { + WebGLVertexArrayObject( + canvas_c::canvas_native_webgl2_create_vertex_array(self.state) + ).into_instance(env) + } + + #[napi] + pub fn delete_query(&self, query: ClassInstance) { + canvas_c::canvas_native_webgl2_delete_query_with_query(query.0, self.state); + } + + #[napi] + pub fn delete_sampler(&self, sampler: &WebGLSampler) { + canvas_c::canvas_native_webgl2_delete_sampler_with_sampler(sampler.0, self.state); + } + + #[napi] + pub fn delete_sync(&self, sync: &WebGLSync) { + canvas_c::canvas_native_webgl2_delete_sync_with_sync(sync.0, self.state); + } + + #[napi] + pub fn delete_transform_feedback(&self, transform_feedback: ClassInstance) { + canvas_c::canvas_native_webgl2_delete_transform_feedback(transform_feedback.0, self.state); + } + + #[napi] + pub fn delete_vertex_array(&self, vertex_array: &WebGLVertexArrayObject) { + canvas_c::canvas_native_webgl2_delete_vertex_array_with_vertex_array(vertex_array.0, self.state); + } + + #[napi] + pub fn draw_arrays_instanced(&self, mode: u32, first: i32, count: i32, instance_count: i32) { + canvas_c::canvas_native_webgl2_draw_arrays_instanced( + mode, first, count, instance_count, self.state, + ) + } + + #[napi] + pub fn draw_buffers(&self, buffers: &[u32]) { + canvas_c::canvas_native_webgl2_draw_buffers(buffers.as_ptr(), buffers.len(), self.state) + } + + #[napi( + ts_args_type = "mode: number, count: number, type: number, offset: number, instanceCount: number" + )] + pub fn draw_elements_instanced(&self, mode: u32, count: i32, type_: u32, offset: i64, instance_count: i32) { + canvas_c::canvas_native_webgl2_draw_elements_instanced( + mode, count, type_, offset as isize, instance_count, self.state, + ) + } + + #[napi( + ts_args_type = "mode: number, start: number,end: number, count: number, type: number, offset: number" + )] + pub fn draw_range_elements(&self, mode: u32, start: u32, end: u32, count: i32, type_: u32, offset: i64) { + canvas_c::canvas_native_webgl2_draw_range_elements( + mode, start, end, count, type_, offset as isize, self.state, + ) + } + + #[napi] + pub fn end_query(&self, target: u32) { + canvas_c::canvas_native_webgl2_end_query(target, self.state); + } + + #[napi] + pub fn end_transform_feedback(&self) { + canvas_c::canvas_native_webgl2_end_transform_feedback(self.state); + } + + #[napi] + pub fn fence_sync(&self, env: Env, condition: u32, flags: u32) -> Result> { + WebGLSync( + canvas_c::canvas_native_webgl2_fence_sync( + condition, flags, self.state, + ) + ).into_instance(env) + } + + #[napi] + pub fn framebuffer_texture_layer(&self, target: u32, attachment: u32, texture: ClassInstance, level: i32, layer: i32) { + canvas_c::canvas_native_webgl2_framebuffer_texture_layer( + target, attachment, texture.0, level, level, self.state, + ) + } + + /* Framebuffers and renderbuffers */ + + /* Uniforms */ + + #[napi] + pub fn get_active_uniform_block_name(&self, program: ClassInstance, uniform_block_index: u32) -> String { + let state = unsafe { &mut *self.state }; + + canvas_webgl::webgl2::canvas_native_webgl2_get_active_uniform_block_name( + program.0, + uniform_block_index, + state.get_inner_mut(), + ) + } + + #[napi] + pub fn get_active_uniform_block_parameter(&self, env: Env, program: ClassInstance, uniform_block_index: u32, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_active_uniform_block_parameter( + program.0, uniform_block_index, pname, self.state, + ); + + match pname { + gl_bindings::UNIFORM_BLOCK_BINDING | + gl_bindings::UNIFORM_BLOCK_DATA_SIZE | + gl_bindings::UNIFORM_BLOCK_ACTIVE_UNIFORMS => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_int32(ret).map(|v| v.into_unknown()) + } + gl_bindings::UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_u32_array(result); + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Uint32, + len, + 0, + ).map(|v| v.into_unknown()) + } + gl_bindings::UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER | + gl_bindings::UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER => { + let ret = canvas_c::canvas_native_webgl_result_get_bool(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.get_boolean(ret).map(|v| v.into_unknown()) + } + _ => env.get_null().map(|v| v.into_unknown()), + } + } + + #[napi] + pub fn get_active_uniforms(&self, env: Env, program: ClassInstance, uniform_indices: &[u32], pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_active_uniforms( + program.0, uniform_indices.as_ptr(), uniform_indices.len(), pname, self.state, + ); + + match pname { + gl_bindings::UNIFORM_TYPE | + gl_bindings::UNIFORM_SIZE => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_u32_array(result); + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Uint32, + len, + 0, + ).map(|v| v.into_unknown()) + } + gl_bindings::UNIFORM_BLOCK_INDEX | + gl_bindings::UNIFORM_OFFSET | + gl_bindings::UNIFORM_ARRAY_STRIDE | + gl_bindings::UNIFORM_MATRIX_STRIDE => unsafe { + let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + let ret = *Box::from_raw(ret); + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})?; + buffer.value.into_typedarray( + TypedArrayType::Int32, + len, + 0, + ).map(|v| v.into_unknown()) + } + gl_bindings::UNIFORM_IS_ROW_MAJOR => { + let ret = canvas_c::canvas_native_webgl_result_into_bool_array(result); + Array::from_vec(&env, ret)?.coerce_to_object().map(|v| v.into_unknown()) + } + _ => env.get_null().map(|v| v.into_unknown()) + } + } + + #[napi] + pub fn get_buffer_sub_data(&self, target: u32, src_byte_offset: i64, mut dst_data: Buffer, dst_offset: Option, length: Option) { + canvas_c::canvas_native_webgl2_get_buffer_sub_data( + target, src_byte_offset as isize, dst_data.as_mut_ptr(), dst_data.len(), dst_offset.unwrap_or_default() as usize, length.unwrap_or_default() as usize, self.state, + ) + } + + #[napi] + pub fn get_frag_data_location(&self, program: ClassInstance, name: String) -> Option { + let state = unsafe { &mut *self.state }; + let ret = canvas_webgl::webgl2::canvas_native_webgl2_get_frag_data_location( + program.0, name.as_str(), state.get_inner_mut(), + ); + if ret != -1 { + Some(ret as u32) + } else { + None + } + } + + #[napi] + pub fn get_indexed_parameter(&self, env: Env, target: u32, index: u32) -> Result { + let state = unsafe { &mut *self.state }; + let ret = canvas_webgl::webgl2::canvas_native_webgl2_get_indexed_parameter( + target, index, state.get_inner_mut(), + ); + + if ret.get_is_buffer() { + WebGLBuffer( + ret.get_buffer_value() as u32 + ).into_instance(env) + .map(|v| v.as_object(env).into_unknown()) + } else { + env.create_int64(ret.get_value() as i64).map(|v| v.into_unknown()) + } + } + + #[napi] + pub fn get_internalformat_parameter(&self, env: Env, target: u32, internalformat: u32, pname: u32) -> Result { + match internalformat { + gl_bindings::RGB | + gl_bindings::RGBA | + gl_bindings::R8UI | + gl_bindings::R8I | + gl_bindings::R16UI | + gl_bindings::R16I | + gl_bindings::R32UI | + gl_bindings::R32I | + gl_bindings::RG8UI | + gl_bindings::RG8I | + gl_bindings::RG16UI | + gl_bindings::RG16I | + gl_bindings::RG32UI | + gl_bindings::RG32I | + gl_bindings::RGBA8UI | + gl_bindings::RGBA8I | + gl_bindings::RGB10_A2UI | + gl_bindings::RGBA16UI | + gl_bindings::RGBA16I | + gl_bindings::RGBA32UI | + gl_bindings::RGBA32I => { + return env.create_arraybuffer(0)? + .value + .into_typedarray( + TypedArrayType::Int32, 0, 0, + ).map(|v| v.into_unknown()) + } + + gl_bindings::R8 | + gl_bindings::RG8 | + gl_bindings::RGB565 | + gl_bindings::RGBA8 | + gl_bindings::SRGB8_ALPHA8 | + gl_bindings::RGB5_A1 | + gl_bindings::RGBA4 | + gl_bindings::RGB10_A2 | + gl_bindings::DEPTH_COMPONENT16 | + gl_bindings::DEPTH_COMPONENT24 | + gl_bindings::DEPTH_COMPONENT32F | + gl_bindings::DEPTH24_STENCIL8 | + gl_bindings::DEPTH32F_STENCIL8 | + gl_bindings::STENCIL_INDEX8 => {} + gl_bindings::R16F | + gl_bindings::RG16F | + gl_bindings::R32F | + gl_bindings::RG32F | + gl_bindings::RGBA32F | + gl_bindings::R11F_G11F_B10F => {} + + _ => { + return env.get_null().map(|v| v.into_unknown()) + } + } + + let result = canvas_c::canvas_native_webgl2_get_internalformat_parameter( + target, internalformat, pname, self.state, + ); + + if pname == gl_bindings::SAMPLES { + let ret = canvas_c::canvas_native_webgl_result_into_i32_array(result); + + if ret.is_null() { + return env.get_null().map(|v| v.into_unknown()); + } + + + let ret = unsafe { *Box::from_raw(ret) }; + let mut ret = ret.into_vec(); + + let ptr = ret.as_mut_ptr(); + let len = ret.len(); + + let buffer = unsafe { env.create_arraybuffer_with_borrowed_data(ptr as _, len * size_of::(), ret, |_, _| {})? }; + return buffer.value.into_typedarray( + TypedArrayType::Int32, + len, + 0, + ).map(|v| v.into_unknown()); + } + + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + + env.get_null().map(|v| v.into_unknown()) + } + + #[napi] + pub fn get_query_parameter(&self, env: Env, query: ClassInstance, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_query_parameter( + query.0, pname, self.state, + ); + + match pname { + gl_bindings::QUERY_RESULT => { + let ret = canvas_c::canvas_native_webgl_result_get_bool( + result + ); + + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + + env.get_boolean(ret).map(|v| v.into_unknown()) + } + gl_bindings::QUERY_RESULT_AVAILABLE => { + let ret = canvas_c::canvas_native_webgl_result_get_u32( + result + ); + + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + + env.create_uint32(ret).map(|v| v.into_unknown()) + } + _ => env.get_null().map(|v| v.into_unknown()) + } + } + + + #[napi] + pub fn get_parameter(&self, env: Env, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_parameter(pname, self.state); + match pname { + gl_bindings::COPY_READ_BUFFER_BINDING | gl_bindings::COPY_WRITE_BUFFER_BINDING => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + WebGLBuffer(ret as u32) + .into_instance(env) + .map(|v| v.as_object(env).into_unknown()) + } + gl_bindings::DRAW_FRAMEBUFFER_BINDING => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + WebGLFramebuffer(ret as u32) + .into_instance(env) + .map(|v| v.as_object(env).into_unknown()) + } + + _ => { + get_parameter_inner( + self.state, env, pname, + ) + } + } + } + + #[napi] + pub fn get_query(&self, env: Env, target: u32, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_query(target, pname, self.state); + if pname == gl_bindings::CURRENT_QUERY { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + return WebGLQuery(ret as u32) + .into_instance(env) + .map(|v| v.as_object(env).into_unknown()); + } + + env.get_null().map(|v| v.into_unknown()) + } + + #[napi] + pub fn get_sampler_parameter(&self, env: Env, sampler: &WebGLSampler, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_sampler_parameter(sampler.0, pname, self.state); + match pname { + gl_bindings::TEXTURE_MAX_LOD | + gl_bindings::TEXTURE_MIN_LOD => { + let ret = canvas_c::canvas_native_webgl_result_get_f32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_double(ret as f64) + .map(|v| v.into_unknown()) + } + gl_bindings::TEXTURE_COMPARE_FUNC | + gl_bindings::TEXTURE_COMPARE_MODE | + gl_bindings::TEXTURE_MAG_FILTER | + gl_bindings::TEXTURE_MIN_FILTER | + gl_bindings::TEXTURE_WRAP_R | + gl_bindings::TEXTURE_WRAP_S | + gl_bindings::TEXTURE_WRAP_T => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_int32(ret) + .map(|v| v.into_unknown()) + } + _ => env.get_null().map(|v| v.into_unknown()) + } + } + + #[napi] + pub fn get_sync_parameter(&self, env: Env, sync: &WebGLSync, pname: u32) -> Result { + let result = canvas_c::canvas_native_webgl2_get_sync_parameter(sync.0, pname, self.state); + match pname { + gl_bindings::OBJECT_TYPE | + gl_bindings::SYNC_STATUS | + gl_bindings::SYNC_CONDITION | + gl_bindings::SYNC_FLAGS => { + let ret = canvas_c::canvas_native_webgl_result_get_i32(result); + canvas_c::canvas_native_webgl_WebGLResult_destroy(result); + env.create_int32(ret) + .map(|v| v.into_unknown()) + } + _ => env.get_null().map(|v| v.into_unknown()) + } + } + + #[napi] + pub fn get_transform_feedback_varying(&self, program: ClassInstance, index: u32) -> Option { + let result = canvas_c::canvas_native_webgl2_get_transform_feedback_varying(program.0, index, self.state); + if result.is_null() { + return None; + } + if canvas_c::canvas_native_webgl_active_info_get_is_empty(result) { + canvas_c::canvas_native_webgl_active_info_destroy(result); + return None; + } + Some( + WebGLActiveInfo(result) + ) + } + + #[napi] + pub fn get_uniform_block_index(&self, program: ClassInstance, uniform_block_name: String) -> u32 { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl2::canvas_native_webgl2_get_uniform_block_index( + program.0, uniform_block_name.as_str(), state.get_inner_mut(), + ) + } + + #[napi] + pub fn get_uniform_indices(&self, program: &WebGLProgram, uniform_names: Vec) -> Result> { + let state = unsafe { &mut *self.state }; + Ok( + canvas_webgl::webgl2::canvas_native_webgl2_get_uniform_indices( + program.0, uniform_names.deref(), state.get_inner_mut(), + ) + ) + } + + #[napi] + pub fn invalidate_framebuffer(&self, target: u32, attachments: &[u32]) { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl2::canvas_native_webgl2_invalidate_framebuffer( + target, attachments, state.get_inner_mut(), + ) + } + + #[napi] + pub fn invalidate_sub_framebuffer(&self, target: u32, attachments: &[u32], x: i32, y: i32, width: i32, height: i32) { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl2::canvas_native_webgl2_invalidate_sub_framebuffer( + target, attachments, x, y, width, height, state.get_inner_mut(), + ) + } + + #[napi] + pub fn is_query(&self, query: &WebGLQuery) -> bool { + canvas_c::canvas_native_webgl2_is_query( + query.0, self.state, + ) + } + + #[napi] + pub fn is_sampler(&self, sampler: ClassInstance) -> bool { + canvas_c::canvas_native_webgl2_is_sampler( + sampler.0, self.state, + ) + } + + #[napi] + pub fn is_sync(&self, sync: &WebGLSync) -> bool { + canvas_c::canvas_native_webgl2_is_sync( + sync.0, self.state, + ) + } + + #[napi] + pub fn is_transform_feedback(&self, transform_feedback: &WebGLTransformFeedback) -> bool { + canvas_c::canvas_native_webgl2_is_transform_feedback( + transform_feedback.0, self.state, + ) + } + + #[napi] + pub fn is_vertex_array(&self, vertex_array: &WebGLVertexArrayObject) -> bool { + canvas_c::canvas_native_webgl2_is_vertex_array( + vertex_array.0, self.state, + ) + } + + #[napi] + pub fn pause_transform_feedback(&self) { + canvas_c::canvas_native_webgl2_pause_transform_feedback( + self.state + ) + } + + #[napi] + pub fn read_buffer(&self, src: u32) { + canvas_c::canvas_native_webgl2_read_buffer( + src, self.state, + ) + } + + #[napi] + pub fn renderbuffer_storage_multisample(&self, target: u32, samples: i32, internal_format: u32, width: i32, height: i32) { + canvas_c::canvas_native_webgl2_renderbuffer_storage_multisample( + target, samples, internal_format, width, height, self.state, + ) + } + + #[napi] + pub fn resume_transform_feedback(&self) { + canvas_c::canvas_native_webgl2_resume_transform_feedback( + self.state + ) + } + + #[napi] + pub fn sampler_parameterf(&self, sampler: ClassInstance, pname: u32, param: f64) { + canvas_c::canvas_native_webgl2_sampler_parameterf( + sampler.0, pname, param as f32, self.state, + ) + } + + /* Uniforms */ + + /* Sync objects */ + + #[napi] + pub fn sampler_parameteri(&self, sampler: ClassInstance, pname: u32, param: i32) { + canvas_c::canvas_native_webgl2_sampler_parameteri( + sampler.0, pname, param, self.state, + ) + } + + + #[napi] + pub fn tex_image_3_d(&self, target: u32, level: i32, internalformat: i32, width: i32, height: i32, depth: i32, border: i32, format: u32, type_: u32, offset_or_source_or_src_data: Either5, src_offset: Option) { + match offset_or_source_or_src_data { + Either5::A(offset) => { + canvas_c::canvas_native_webgl2_tex_image3d_none( + target, level, internalformat, width, height, depth, border, format, type_, offset as usize, self.state, + ) + } + Either5::B(buffer) => { + canvas_c::canvas_native_webgl2_tex_image3d_offset( + target, level, internalformat, width, height, depth, border, format, type_, buffer.as_ptr(), buffer.len(), src_offset.unwrap_or_default() as usize, self.state, + ) + } + Either5::C(c2d) => { + canvas_c::canvas_native_webgl2_tex_image3d_canvas2d( + target, level, internalformat, width, height, depth, border, format, type_, c2d.context, self.state, + ) + } + Either5::D(gl) => { + canvas_c::canvas_native_webgl2_tex_image3d_webgl( + target, level, internalformat, width, height, depth, border, format, type_, gl.state, self.state, + ) + } + Either5::E(gl2) => { + canvas_c::canvas_native_webgl2_tex_image3d_webgl( + target, level, internalformat, width, height, depth, border, format, type_, gl2.state, self.state, + ) + } + } + } + + #[napi] + pub fn tex_storage_2_d(&self, target: u32, levels: i32, internalformat: u32, width: i32, height: i32) { + canvas_c::canvas_native_webgl2_tex_storage2d( + target, levels, internalformat, width, height, self.state, + ) + } + + #[napi] + pub fn tex_storage_3_d(&self, target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32) { + canvas_c::canvas_native_webgl2_tex_storage3d( + target, levels, internalformat, width, height, depth, self.state, + ) + } + + #[napi] + pub fn tex_sub_image_3_d(&self, target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, src_data: Either5, src_offset: Option) { + match src_data { + Either5::A(offset) => { + canvas_c::canvas_native_webgl2_tex_sub_image3d_none( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, offset as usize, self.state, + ) + } + Either5::B(buffer) => { + canvas_c::canvas_native_webgl2_tex_sub_image3d_offset( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, buffer.as_ptr(), buffer.len(), src_offset.unwrap_or_default() as usize, self.state, + ) + } + Either5::C(c2d) => { + canvas_c::canvas_native_webgl2_tex_sub_image3d_canvas2d( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, c2d.context, self.state, + ) + } + Either5::D(gl) => { + canvas_c::canvas_native_webgl2_tex_sub_image3d_webgl( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, gl.state, self.state, + ) + } + Either5::E(gl2) => { + canvas_c::canvas_native_webgl2_tex_sub_image3d_webgl( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, gl2.state, self.state, + ) + } + } + } + + #[napi] + pub fn transform_feedback_varyings(&self, program: &WebGLProgram, varyings: Vec, buffer_mode: u32) { + let state = unsafe { &mut *self.state }; + canvas_webgl::webgl2::canvas_native_webgl2_transform_feedback_varyings( + program.0, varyings.deref(), buffer_mode, state.get_inner_mut(), + ) + } + + #[napi(js_name = "uniform1ui")] + pub fn uniform1ui(&self, location: &WebGLUniformLocation, v0: u32) { + canvas_c::canvas_native_webgl2_uniform1ui(location.0, v0, self.state) + } + + #[napi(js_name = "uniform1uiv")] + pub fn uniform1uiv(&self, location: &WebGLUniformLocation, data: Either<&[u32], Uint32Array>) { + match data { + Either::A(array) => { + canvas_c::canvas_native_webgl2_uniform1uiv(location.0, array.as_ptr(), array.len(), self.state) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_uniform1uiv(location.0, buffer.as_ptr(), buffer.len(), self.state) + } + } + } + + #[napi(js_name = "uniform2ui")] + pub fn uniform2ui(&self, location: &WebGLUniformLocation, v0: u32, v1: u32) { + canvas_c::canvas_native_webgl2_uniform2ui(location.0, v0, v1, self.state) + } + + #[napi(js_name = "uniform2uiv")] + pub fn uniform2uiv(&self, location: &WebGLUniformLocation, data: Either<&[u32], Uint32Array>) { + match data { + Either::A(array) => { + canvas_c::canvas_native_webgl2_uniform2uiv(location.0, array.as_ptr(), array.len(), self.state) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_uniform2uiv(location.0, buffer.as_ptr(), buffer.len(), self.state) + } + } + } + + /* Sync objects */ + + /* Miscellaneous constants */ + + #[napi(js_name = "uniform3ui")] + pub fn uniform3ui(&self, location: &WebGLUniformLocation, v0: u32, v1: u32, v2: u32) { + canvas_c::canvas_native_webgl2_uniform3ui(location.0, v0, v1, v2, self.state) + } + + #[napi(js_name = "uniform3uiv")] + pub fn uniform3uiv(&self, location: &WebGLUniformLocation, data: Either<&[u32], Uint32Array>) { + match data { + Either::A(array) => { + canvas_c::canvas_native_webgl2_uniform3uiv(location.0, array.as_ptr(), array.len(), self.state) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_uniform3uiv(location.0, buffer.as_ptr(), buffer.len(), self.state) + } + } + } + + #[napi(js_name = "uniform4ui")] + pub fn uniform4ui(&self, location: &WebGLUniformLocation, v0: u32, v1: u32, v2: u32, v3: u32) { + canvas_c::canvas_native_webgl2_uniform4ui(location.0, v0, v1, v2, v3, self.state) + } + + #[napi(js_name = "uniform4uiv")] + pub fn uniform4uiv(&self, location: &WebGLUniformLocation, data: Either<&[u32], Uint32Array>) { + match data { + Either::A(array) => { + canvas_c::canvas_native_webgl2_uniform4uiv(location.0, array.as_ptr(), array.len(), self.state) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_uniform4uiv(location.0, buffer.as_ptr(), buffer.len(), self.state) + } + } + } + + #[napi] + pub fn uniform_block_binding(&self, program: &WebGLProgram, uniform_block_index: u32, uniform_block_binding: u32) { + canvas_c::canvas_native_webgl2_uniform_block_binding( + program.0, uniform_block_index, uniform_block_binding, self.state, + ) + } + + #[napi(js_name = "uniformMatrix2x3fv")] + pub fn uniform_matrix2x3fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix2x3fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi(js_name = "uniformMatrix2x4fv")] + pub fn uniform_matrix2x4fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix2x4fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi(js_name = "uniformMatrix3x2fv")] + pub fn uniform_matrix3x2fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix3x2fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi(js_name = "uniformMatrix3x4fv")] + pub fn uniform_matrix3x4fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix3x4fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi(js_name = "uniformMatrix4x2fv")] + pub fn uniform_matrix4x2fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix4x2fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi(js_name = "uniformMatrix4x3fv")] + pub fn uniform_matrix4x3fv(&self, location: &WebGLUniformLocation, transpose: bool, data: Float32Array) { + canvas_c::canvas_native_webgl2_uniform_matrix4x3fv(location.0, transpose, data.as_ptr(), data.len(), self.state) + } + + #[napi] + pub fn vertex_attrib_divisor(&self, index: u32, divisor: u32) { + canvas_c::canvas_native_webgl2_vertex_attrib_divisor(index, divisor, self.state) + } + + #[napi(js_name = "vertexAttribI4i")] + pub fn vertex_attrib_i4i(&self, index: u32, v0: i32, v1: i32, v2: i32, v3: i32) { + canvas_c::canvas_native_webgl2_vertex_attrib_i4i(index, v0, v1, v2, v3, self.state) + } + + #[napi(js_name = "vertexAttribI4ui")] + pub fn vertex_attrib_i4ui(&self, index: u32, v0: u32, v1: u32, v2: u32, v3: u32) { + canvas_c::canvas_native_webgl2_vertex_attrib_i4ui(index, v0, v1, v2, v3, self.state) + } + + #[napi(js_name = "vertexAttribI4iv")] + pub fn vertex_attrib_i4iv(&self, index: u32, value: Either<&[i32], Int32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl2_vertex_attrib_i4iv( + index, array.as_ptr(), array.len(), self.state, + ) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_vertex_attrib_i4iv( + index, buffer.as_ptr(), buffer.len(), self.state, + ) + } + } + } + + + #[napi(js_name = "vertexAttribI4uiv")] + pub fn vertex_attrib_i4uiv(&self, index: u32, value: Either<&[u32], Uint32Array>) { + match value { + Either::A(array) => { + canvas_c::canvas_native_webgl2_vertex_attrib_i4uiv( + index, array.as_ptr(), array.len(), self.state, + ) + } + Either::B(buffer) => { + canvas_c::canvas_native_webgl2_vertex_attrib_i4uiv( + index, buffer.as_ptr(), buffer.len(), self.state, + ) + } + } + } + + /* Miscellaneous constants */ +} + +impl_webgl_context_constants!(web_g_l_2_rendering_context); +impl_webgl2_context_constants!(web_g_l_2_rendering_context); \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2/webgl_query.rs b/napi/canvas-napi/src/gl2/webgl_query.rs new file mode 100644 index 000000000..94325b1ce --- /dev/null +++ b/napi/canvas-napi/src/gl2/webgl_query.rs @@ -0,0 +1,5 @@ +use napi::*; +use napi_derive::napi; + +#[napi(js_name = "WebGLQuery")] +pub struct WebGLQuery(pub(crate) u32); \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2/webgl_sampler.rs b/napi/canvas-napi/src/gl2/webgl_sampler.rs new file mode 100644 index 000000000..76798283f --- /dev/null +++ b/napi/canvas-napi/src/gl2/webgl_sampler.rs @@ -0,0 +1,5 @@ +use napi::*; +use napi_derive::napi; + +#[napi(js_name = "WebGLSampler")] +pub struct WebGLSampler(pub(crate) u32); \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2/webgl_sync.rs b/napi/canvas-napi/src/gl2/webgl_sync.rs new file mode 100644 index 000000000..16842049a --- /dev/null +++ b/napi/canvas-napi/src/gl2/webgl_sync.rs @@ -0,0 +1,14 @@ +use napi::bindgen_prelude::ObjectFinalize; +use napi::*; +use napi_derive::napi; + +#[napi(js_name = "WebGLSync", custom_finalize)] +pub struct WebGLSync(pub(crate) *const canvas_c::WebGLSync); + +impl ObjectFinalize for WebGLSync { + fn finalize(self, _: Env) -> Result<()> { + canvas_c::canvas_native_webgl2_sync_destroy(self.0); + Ok(()) + } +} + diff --git a/napi/canvas-napi/src/gl2/webgl_transform_feedback.rs b/napi/canvas-napi/src/gl2/webgl_transform_feedback.rs new file mode 100644 index 000000000..e65f6a129 --- /dev/null +++ b/napi/canvas-napi/src/gl2/webgl_transform_feedback.rs @@ -0,0 +1,5 @@ +use napi::*; +use napi_derive::napi; + +#[napi(js_name = "WebGLTransformFeedback")] +pub struct WebGLTransformFeedback(pub(crate) u32); \ No newline at end of file diff --git a/napi/canvas-napi/src/gl2/webgl_vertex_array_object.rs b/napi/canvas-napi/src/gl2/webgl_vertex_array_object.rs new file mode 100644 index 000000000..a6e2e9057 --- /dev/null +++ b/napi/canvas-napi/src/gl2/webgl_vertex_array_object.rs @@ -0,0 +1,5 @@ +use napi::*; +use napi_derive::napi; + +#[napi(js_name = "WebGLVertexArrayObject")] +pub struct WebGLVertexArrayObject(pub(crate) u32); \ No newline at end of file diff --git a/napi/canvas-napi/tsconfig.json b/napi/canvas-napi/tsconfig.json new file mode 100644 index 000000000..47b610892 --- /dev/null +++ b/napi/canvas-napi/tsconfig.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "outDir": "./dist", + "sourceMap": true, + "declaration": true, + "target": "ES2020", + "noEmitHelpers": false, + "module": "ESNext", + "lib": ["ESNext", "dom"], + "skipLibCheck": true, + "skipDefaultLibCheck": true + }, + "include": ["**/*.ts", "references.d.ts"] +} diff --git a/napi/canvas-napi/utils/index.js b/napi/canvas-napi/utils/index.js new file mode 100644 index 000000000..df9c9839c --- /dev/null +++ b/napi/canvas-napi/utils/index.js @@ -0,0 +1,13 @@ +const { cancelAnimationFrame, requestAnimationFrame, time } = require('./raf'); +module.exports.cancelAnimationFrame = cancelAnimationFrame; +module.exports.requestAnimationFrame = requestAnimationFrame; +module.exports.time = time; + +const { dispatchToMainThread, dispatchToUIThread, isMainThread } = require('./mainthread-helper'); + +const { queueMacrotask } = require('./macrotask-scheduler'); + +module.exports.dispatchToMainThread = dispatchToMainThread; +module.exports.dispatchToUIThread = dispatchToUIThread; +module.exports.isMainThread = isMainThread; +module.exports.queueMacrotask = queueMacrotask; diff --git a/napi/canvas-napi/utils/macrotask-scheduler.js b/napi/canvas-napi/utils/macrotask-scheduler.js new file mode 100644 index 000000000..641c4579d --- /dev/null +++ b/napi/canvas-napi/utils/macrotask-scheduler.js @@ -0,0 +1,34 @@ +const { dispatchToMainThread } = require('./mainthread-helper'); + +let scheduled = false; +/** + * @type {Array} + */ +let macroTaskQueue = []; + +function drainMacrotaskQueue() { + const currentQueue = macroTaskQueue; + macroTaskQueue = []; + scheduled = false; + currentQueue.forEach((task) => { + try { + task(); + } catch (err) { + const msg = err ? err.stack || err : err; + } + }); +} + +/** + * + * @param {function(): void} task + */ +function queueMacrotask(task) { + macroTaskQueue.push(task); + if (!scheduled) { + scheduled = true; + dispatchToMainThread(drainMacrotaskQueue); + } +} + +module.exports.queueMacrotask = queueMacrotask; diff --git a/napi/canvas-napi/utils/mainthread-helper.js b/napi/canvas-napi/utils/mainthread-helper.js new file mode 100644 index 000000000..bc50f4849 --- /dev/null +++ b/napi/canvas-napi/utils/mainthread-helper.js @@ -0,0 +1,33 @@ +/** + * + * @param {function(): void} func + */ +function dispatchToMainThread(func) { + NSOperationQueue.mainQueue.addOperationWithBlock(func); +} + +/** + * + * @returns {boolean} + */ +function isMainThread() { + return NSThread.isMainThread; +} + +/** + * + * @param {function():void} func + */ +function dispatchToUIThread(func) { + const runloop = CFRunLoopGetMain(); + if (runloop && func) { + CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, func); + CFRunLoopWakeUp(runloop); + } else if (func) { + func(); + } +} + +module.exports.dispatchToMainThread = dispatchToMainThread; +module.exports.isMainThread = isMainThread; +module.exports.dispatchToUIThread = dispatchToUIThread; diff --git a/napi/canvas-napi/utils/raf/fps-meter.js b/napi/canvas-napi/utils/raf/fps-meter.js new file mode 100644 index 000000000..3e339387c --- /dev/null +++ b/napi/canvas-napi/utils/raf/fps-meter.js @@ -0,0 +1,103 @@ +class FrameHandlerImpl extends NSObject { + /** + * @type {WeakRef} + */ + _owner; + + static { + NativeClass(this); + } + + /** + * + * @param {WeakRef} owner + * @returns {FrameHandlerImpl} + */ + static initWithOwner(owner) { + const handler = FrameHandlerImpl.new(); + handler._owner = owner; + + return handler; + } + + /** + * + * @param {CADisplayLink} sender + */ + handleFrame(sender) { + const owner = this._owner?.deref(); + if (owner) { + owner._handleFrame(sender); + } + } + + static ObjCExposedMethods = { + handleFrame: { returns: interop.types.void, params: [CADisplayLink] }, + }; +} + +class FPSCallback { + /** + * @type {boolean} + */ + running; + /** + * @type {Function} + */ + onFrame; + /** + * @type {CADisplayLink} + */ + displayLink; + /** + * @type {FrameHandlerImpl} + */ + impl; + + /** + * + * @param {function(number): void} onFrame + */ + constructor(onFrame) { + this.onFrame = onFrame; + + this.impl = FrameHandlerImpl.initWithOwner(new WeakRef(this)); + + this.displayLink = NSScreen.mainScreen.displayLinkWithTargetSelector(this.impl, 'handleFrame'); + this.displayLink.isPaused = true; + this.displayLink.addToRunLoopForMode(NSRunLoop.currentRunLoop, NSDefaultRunLoopMode); + } + + start() { + if (this.running) { + return; + } + + this.running = true; + this.displayLink.isPaused = false; + } + + stop() { + if (!this.running) { + return; + } + + this.displayLink.isPaused = true; + this.running = false; + } + + /** + * + * @param {CADisplayLink} sender + */ + _handleFrame(sender) { + if (!this.running) { + return; + } + + // timestamp is CFTimeInterval, which is in seconds, the onFrame callback expects millis, so multiply by 1000 + this.onFrame(sender.timestamp * 1000); + } +} + +module.exports.FPSCallback = FPSCallback; diff --git a/napi/canvas-napi/utils/raf/index.js b/napi/canvas-napi/utils/raf/index.js new file mode 100644 index 000000000..fb72a5f07 --- /dev/null +++ b/napi/canvas-napi/utils/raf/index.js @@ -0,0 +1,146 @@ +const { queueMacrotask } = require('../macrotask-scheduler'); +const { FPSCallback } = require('./fps-meter'); + +/** + * @returns {function(): number} The current time in milliseconds. + */ +const time = global.__time || Date.now; + +function getTimeInFrameBase() { + return time(); +} + +let animationId = 0; +/** + * @type { [key: string]: function(time: number): void } + */ +let currentFrameAnimationCallbacks = {}; // requests that were scheduled in this frame and must be called ASAP +let currentFrameScheduled = false; + +/** + * @type { [key: string]: function(time: number): void } + */ +let nextFrameAnimationCallbacks = {}; // requests there were scheduled in another request and must be called in the next frame +let shouldStop = true; +let inAnimationFrame = false; +/** + * @type {FPSCallback} + */ +let fpsCallback; +let lastFrameTime = 0; + +function getNewId() { + return animationId++; +} + +function ensureNative() { + if (fpsCallback) { + return; + } + fpsCallback = new FPSCallback(doFrame); +} + +/** + * + * @param { [key: string]: function(time: number): void } thisFrameCbs + * @param {number} frameTime + * + */ +function callAnimationCallbacks(thisFrameCbs, frameTime) { + inAnimationFrame = true; + for (const animationId in thisFrameCbs) { + if (thisFrameCbs[animationId]) { + try { + thisFrameCbs[animationId](frameTime); + } catch (err) { + const msg = err ? err.stack || err : err; + } + } + } + inAnimationFrame = false; +} + +function doCurrentFrame() { + // if we're not getting accurate frame times + // set last frame time as the current time + if (!fpsCallback || !fpsCallback.running) { + lastFrameTime = getTimeInFrameBase(); + } + currentFrameScheduled = false; + const thisFrameCbs = currentFrameAnimationCallbacks; + currentFrameAnimationCallbacks = {}; + callAnimationCallbacks(thisFrameCbs, lastFrameTime); +} + +/** + * + * @param {number} currentTimeMillis + */ +function doFrame(currentTimeMillis) { + lastFrameTime = currentTimeMillis; + shouldStop = true; + const thisFrameCbs = nextFrameAnimationCallbacks; + nextFrameAnimationCallbacks = {}; + callAnimationCallbacks(thisFrameCbs, lastFrameTime); + if (shouldStop) { + fpsCallback.stop(); // TODO: check performance without stopping to allow consistent frame times + } +} + +function ensureCurrentFrameScheduled() { + if (!currentFrameScheduled) { + currentFrameScheduled = true; + queueMacrotask(doCurrentFrame); + } +} + +/** + * + * @param {Function} callback + * @returns {Function} + */ +const zonedCallback = function (callback) { + if (global.zone) { + // Zone v0.5.* style callback wrapping + return global.zone.bind(callback); + } + if (global.Zone) { + // Zone v0.6.* style callback wrapping + return global.Zone.current.wrap(callback); + } else { + return callback; + } +}; + +/** + * + * @param {function(time: number): void} cb + * @returns {number} + */ +function requestAnimationFrame(cb) { + const animId = getNewId(); + if (!inAnimationFrame) { + ensureCurrentFrameScheduled(); + currentFrameAnimationCallbacks[animId] = zonedCallback(cb); + return animId; + } + ensureNative(); + nextFrameAnimationCallbacks[animId] = zonedCallback(cb); + shouldStop = false; + fpsCallback.start(); + + return animId; +} + +/** + * + * @param {number} id + */ +function cancelAnimationFrame(id) { + delete currentFrameAnimationCallbacks[id]; + delete nextFrameAnimationCallbacks[id]; +} + +module.exports.requestAnimationFrame = requestAnimationFrame; +module.exports.cancelAnimationFrame = cancelAnimationFrame; +module.exports.time = time; diff --git a/packages/canvas/WebGL/WebGLRenderingContext/index.ts b/packages/canvas/WebGL/WebGLRenderingContext/index.ts index 59683f19f..e9402c7e7 100644 --- a/packages/canvas/WebGL/WebGLRenderingContext/index.ts +++ b/packages/canvas/WebGL/WebGLRenderingContext/index.ts @@ -941,7 +941,6 @@ export class WebGLRenderingContextBase extends WebGLRenderingCommon { } } } else if (border && typeof border.tagName === 'string' && border.tagName === 'CANVAS' && border._canvas instanceof Canvas) { - console.log('border._canvas', border._canvas); this.native.texImage2D(target, level, internalformat, width, height, border._canvas.native); } else if (border instanceof ImageData) { this.native.texImage2D(target, level, internalformat, width, height, (border).native); 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 6d70b135d..f82aacf28 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