@geastack/native-webgl-angle 0.1.17 → 0.1.18

package/geatsc-plugin-uniforms.mjs

@@ -349,42 +349,86 @@ export function isUniformNumberArray( value ) {
 
 }
 
-/** @param {NativeUniformValue} value @return {value is Vector2[]} */
-function isVector2Array( value ) {
+/**
+ * One element of a uniform array whose first element is the given kind. Read
+ * through \`Array.isArray\` and \`instanceof\` on the element itself rather than
+ * through the value narrowed to that array type: the value is stored as the
+ * uniform union, and claiming one array arm for it is an array-to-array
+ * conversion with no runtime form.
+ */
+
+/** @param {NativeUniformValue} value @param {number} index @return {Vector2} */
+function vector2ArrayElement( value, index ) {
+
+\tif ( Array.isArray( value ) ) {
+
+\t\tconst element = value[ index ];
+
+\t\tif ( element instanceof Vector2 ) return element;
+
+\t}
 
-\treturn Array.isArray( value ) && value.length > 0 && value[ 0 ] instanceof Vector2;
+\tthrow new Error( 'THREE.UniformsUtils: a uniform array mixes Vector2 with other values.' );
 
 }
 
-/** @param {NativeUniformValue} value @return {value is Vector3[]} */
-function isVector3Array( value ) {
+/** @param {NativeUniformValue} value @param {number} index @return {Vector3} */
+function vector3ArrayElement( value, index ) {
+
+\tif ( Array.isArray( value ) ) {
 
-\treturn Array.isArray( value ) && value.length > 0 && value[ 0 ] instanceof Vector3;
+\t\tconst element = value[ index ];
+
+\t\tif ( element instanceof Vector3 ) return element;
+
+\t}
+
+\tthrow new Error( 'THREE.UniformsUtils: a uniform array mixes Vector3 with other values.' );
 
 }
 
-/** @param {NativeUniformValue} value @return {value is Vector4[]} */
-function isVector4Array( value ) {
+/** @param {NativeUniformValue} value @param {number} index @return {Vector4} */
+function vector4ArrayElement( value, index ) {
+
+\tif ( Array.isArray( value ) ) {
 
-\treturn Array.isArray( value ) && value.length > 0 && value[ 0 ] instanceof Vector4;
+\t\tconst element = value[ index ];
+
+\t\tif ( element instanceof Vector4 ) return element;
+
+\t}
+
+\tthrow new Error( 'THREE.UniformsUtils: a uniform array mixes Vector4 with other values.' );
 
 }
 
-/** @param {NativeUniformValue} value @return {value is Matrix4[]} */
-function isMatrix4Array( value ) {
+/** @param {NativeUniformValue} value @param {number} index @return {Matrix4} */
+function matrix4ArrayElement( value, index ) {
+
+\tif ( Array.isArray( value ) ) {
+
+\t\tconst element = value[ index ];
+
+\t\tif ( element instanceof Matrix4 ) return element;
 
-\treturn Array.isArray( value ) && value.length > 0 && value[ 0 ] instanceof Matrix4;
+\t}
+
+\tthrow new Error( 'THREE.UniformsUtils: a uniform array mixes Matrix4 with other values.' );
 
 }
 
-/** @param {NativeUniformValue} value @return {value is Array<Texture|null>} */
-export function isUniformTextureArray( value ) {
+/** @param {NativeUniformValue} value @param {number} index @return {Texture|null} */
+function textureArrayElement( value, index ) {
 
-\tif ( ! Array.isArray( value ) || value.length === 0 ) return false;
+\tif ( Array.isArray( value ) ) {
 
-\tconst first = value[ 0 ];
+\t\tconst element = value[ index ];
 
-\treturn first === null || first instanceof Texture;
+\t\tif ( element === null || element instanceof Texture ) return element;
+
+\t}
+
+\tthrow new Error( 'THREE.UniformsUtils: a uniform array mixes textures with other values.' );
 
 }
 
@@ -423,63 +467,70 @@ export function cloneUniformValue( value ) {
 
 \tif ( isUniformNumberArray( value ) ) return value.slice();
 
-\tif ( isVector2Array( value ) ) {
+\tif ( Array.isArray( value ) && value.length > 0 ) {
 
-\t\t/** @type {Vector2[]} */
-\t\tconst cloned = [];
+\t\tconst first = value[ 0 ];
+\t\tconst length = value.length;
 
-\t\tfor ( let i = 0, l = value.length; i < l; i ++ ) cloned.push( value[ i ].clone() );
+\t\tif ( first instanceof Vector2 ) {
 
-\t\treturn cloned;
+\t\t\t/** @type {Vector2[]} */
+\t\t\tconst cloned = [];
 
-\t}
+\t\t\tfor ( let i = 0; i < length; i ++ ) cloned.push( vector2ArrayElement( value, i ).clone() );
+
+\t\t\treturn cloned;
 
-\tif ( isVector3Array( value ) ) {
+\t\t}
 
-\t\t/** @type {Vector3[]} */
-\t\tconst cloned = [];
+\t\tif ( first instanceof Vector3 ) {
 
-\t\tfor ( let i = 0, l = value.length; i < l; i ++ ) cloned.push( value[ i ].clone() );
+\t\t\t/** @type {Vector3[]} */
+\t\t\tconst cloned = [];
 
-\t\treturn cloned;
+\t\t\tfor ( let i = 0; i < length; i ++ ) cloned.push( vector3ArrayElement( value, i ).clone() );
 
-\t}
+\t\t\treturn cloned;
 
-\tif ( isVector4Array( value ) ) {
+\t\t}
 
-\t\t/** @type {Vector4[]} */
-\t\tconst cloned = [];
+\t\tif ( first instanceof Vector4 ) {
 
-\t\tfor ( let i = 0, l = value.length; i < l; i ++ ) cloned.push( value[ i ].clone() );
+\t\t\t/** @type {Vector4[]} */
+\t\t\tconst cloned = [];
 
-\t\treturn cloned;
+\t\t\tfor ( let i = 0; i < length; i ++ ) cloned.push( vector4ArrayElement( value, i ).clone() );
 
-\t}
+\t\t\treturn cloned;
 
-\tif ( isMatrix4Array( value ) ) {
+\t\t}
 
-\t\t/** @type {Matrix4[]} */
-\t\tconst cloned = [];
+\t\tif ( first instanceof Matrix4 ) {
 
-\t\tfor ( let i = 0, l = value.length; i < l; i ++ ) cloned.push( value[ i ].clone() );
+\t\t\t/** @type {Matrix4[]} */
+\t\t\tconst cloned = [];
 
-\t\treturn cloned;
+\t\t\tfor ( let i = 0; i < length; i ++ ) cloned.push( matrix4ArrayElement( value, i ).clone() );
 
-\t}
+\t\t\treturn cloned;
+
+\t\t}
 
-\tif ( isUniformTextureArray( value ) ) {
+\t\tif ( first === null || first instanceof Texture ) {
 
-\t\t/** @type {Array<Texture|null>} */
-\t\tconst cloned = [];
+\t\t\t/** @type {Array<Texture|null>} */
+\t\t\tconst cloned = [];
 
-\t\tfor ( let i = 0, l = value.length; i < l; i ++ ) {
+\t\t\tfor ( let i = 0; i < length; i ++ ) {
 
-\t\t\tconst texture = value[ i ];
-\t\t\tcloned.push( texture === null ? null : texture.clone() );
+\t\t\t\tconst texture = textureArrayElement( value, i );
+\t\t\t\tcloned.push( texture === null ? null : texture.clone() );
 
-\t\t}
+\t\t\t}
 
-\t\treturn cloned;
+\t\t\treturn cloned;
+
+\t\t}
 
 \t}
 
@@ -856,8 +907,7 @@ function ${name}( gl, v, textures ) {
 
 \t}
 
-\tconst list = requireTextureArray( v );
-\tconst n = list.length;
+\tconst n = requireTextureArrayLength( v );
 
 \tconst units = allocTexUnits( manager, n );
 
@@ -887,7 +937,7 @@ ${
 }
 \tfor ( let i = 0; i !== n; ++ i ) {
 
-\t\tconst texture = list[ i ];
+\t\tconst texture = textureArrayElement( v, i );
 \t\tmanager.${setter}( texture === null ? ${shadowAware ? 'emptyTexture2D' : empty} : texture, units[ i ] );
 
 \t}
@@ -1033,7 +1083,7 @@ import { Matrix4 } from '../../math/Matrix4.js';
 import { Vector2 } from '../../math/Vector2.js';
 import { Vector3 } from '../../math/Vector3.js';
 import { Vector4 } from '../../math/Vector4.js';
-import { isUniformNumberArray, isUniformTextureArray } from '../shaders/UniformsUtils.js';
+import { isUniformNumberArray } from '../shaders/UniformsUtils.js';
 import {
 ${nativeLightUniformClassNames.map((name) => `\t${name},`).join('\n')}
 } from '../shaders/UniformsLib.js';
@@ -1124,10 +1174,39 @@ function requireUintUniformArray( value ) {
 
 }
 
-/** @param {NativeUniformValue} value @return {Array<Texture|null>} */
-function requireTextureArray( value ) {
+/**
+ * A sampler array value is read element by element, never returned as a
+ * narrowed \`Array<Texture|null>\`: a call site can hand the setter a value whose
+ * static carrier is another array arm (a \`number[]\` passed to \`setValue\` by
+ * name), and claiming that array for the texture arm is an array-to-array
+ * conversion with no runtime form. Validated up front, as before, so a value
+ * that is not a texture array throws before any texture unit is allocated.
+ * @param {NativeUniformValue} value @return {number}
+ */
+function requireTextureArrayLength( value ) {
+
+\tif ( Array.isArray( value ) && value.length > 0 ) {
+
+\t\tconst first = value[ 0 ];
+
+\t\tif ( first === null || first instanceof Texture ) return value.length;
+
+\t}
+
+\tthrow new Error( 'THREE.WebGLUniforms: sampler array uniform value must be an array of textures.' );
+
+}
+
+/** @param {NativeUniformValue} value @param {number} index @return {Texture|null} */
+function textureArrayElement( value, index ) {
+
+\tif ( Array.isArray( value ) ) {
 
-\tif ( isUniformTextureArray( value ) ) return value;
+\t\tconst element = value[ index ];
+
+\t\tif ( element === null || element instanceof Texture ) return element;
+
+\t}
 
 \tthrow new Error( 'THREE.WebGLUniforms: sampler array uniform value must be an array of textures.' );
 

package/geatsc-plugin.mjs

@@ -678,7 +678,7 @@ inline double gea_three_resource_read_native(std::string name, const gea::Ref<ge
     "threeWebGLDrawBuffers",
     "gea_three_webgl_draw_buffers",
     "void",
-    'extern "C" void gea_three_webgl_draw_buffers(double attachment);',
+    'extern "C" void gea_three_webgl_draw_buffers(double count, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7);',
   ],
 
   [

package/native/angle_webgl_host.mm

@@ -2327,8 +2327,11 @@ extern "C" void gea_three_webgl_renderbuffer_storage(double target, double inter
   geaTrapCheck("gea_three_webgl_renderbuffer_storage"); GEA_WEBGL_VOID("renderbufferStorage"); gWebGL.glRenderbufferStorage(asGLenum(target), asGLenum(internalFormat), asGLsizei(width), asGLsizei(height)); }
 extern "C" void gea_three_webgl_framebuffer_renderbuffer(double target, double attachment, double renderbuffertarget, double renderbuffer) {
   geaTrapCheck("gea_three_webgl_framebuffer_renderbuffer"); GEA_WEBGL_VOID("framebufferRenderbuffer"); gWebGL.glFramebufferRenderbuffer(asGLenum(target), asGLenum(attachment), asGLenum(renderbuffertarget), asGLuint(renderbuffer)); }
-extern "C" void gea_three_webgl_draw_buffers(double attachment) {
-  geaTrapCheck("gea_three_webgl_draw_buffers"); GEA_WEBGL_VOID("drawBuffers"); const GLenum glAttachment = asGLenum(attachment); gWebGL.glDrawBuffers(1, &glAttachment); }
+extern "C" void gea_three_webgl_draw_buffers(double count, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7) {
+  geaTrapCheck("gea_three_webgl_draw_buffers"); GEA_WEBGL_VOID("drawBuffers");
+  const GLenum attachments[8] = {asGLenum(a0), asGLenum(a1), asGLenum(a2), asGLenum(a3), asGLenum(a4), asGLenum(a5), asGLenum(a6), asGLenum(a7)};
+  const GLsizei n = std::max<GLsizei>(0, std::min<GLsizei>(asGLsizei(count), 8));
+  gWebGL.glDrawBuffers(n, attachments); }
 
 extern "C" void gea_three_webgl_clear_color(double r, double g, double b, double a) {
   geaTrapCheck("gea_three_webgl_clear_color"); GEA_WEBGL_VOID("clearColor");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/native-webgl-angle",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Typed native WebGL compatibility layer backed by ANGLE/Metal",
   "license": "Apache-2.0",
   "repository": {

package/src/nativeWebGL.ts

@@ -1213,7 +1213,12 @@ export class NativeWebGL2RenderingContext {
   framebufferTextureLayer(target: number, attachment: number, texture: NativeHandle | null, level: number, layer: number): void {
     threeWebGLFramebufferTextureLayer(target, attachment, nullableNativeHandle(texture), level, layer)
   }
-  drawBuffers(buffers: number[]): void { nativeWebGLDrawBuffers(buffers[0] ?? this.COLOR_ATTACHMENT0) }
+  /** Every listed buffer reaches GL (up to 8, the MRT limit the host passes), so multiple render targets write all their attachments. */
+  drawBuffers(buffers: number[]): void {
+    const count = Math.min(buffers.length, 8)
+    const at = (index: number): number => index < count ? buffers[index] : this.NONE
+    nativeWebGLDrawBuffers(count, at(0), at(1), at(2), at(3), at(4), at(5), at(6), at(7))
+  }
 
   clearColor(r: number, g: number, b: number, a: number): void { nativeWebGLClearColor(r, g, b, a) }
   clear(mask: number): void { nativeWebGLClear(mask) }

package/src/nativeWebGLHost.ts

@@ -148,7 +148,7 @@ export function nativeWebGLBindRenderbuffer(target: number, renderbuffer: number
 export function nativeWebGLDeleteRenderbuffer(renderbuffer: number): void { threeWebGLDeleteRenderbuffer(renderbuffer) }
 export function nativeWebGLRenderbufferStorage(target: number, internalFormat: number, width: number, height: number): void { threeWebGLRenderbufferStorage(target, internalFormat, width, height) }
 export function nativeWebGLFramebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: number): void { threeWebGLFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) }
-export function nativeWebGLDrawBuffers(attachment: number): void { threeWebGLDrawBuffers(attachment) }
+export function nativeWebGLDrawBuffers(count: number, a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number): void { threeWebGLDrawBuffers(count, a0, a1, a2, a3, a4, a5, a6, a7) }
 
 export function nativeWebGLClearColor(r: number, g: number, b: number, a: number): void { threeWebGLClearColor(r, g, b, a) }
 export function nativeWebGLClear(mask: number): void { threeWebGLClear(mask) }
@@ -303,7 +303,7 @@ declare function threeWebGLRenderbufferStorage(target: number, internalFormat: n
 /** @gea-host-inert Native state only; retains no script references and invokes no script. */
 declare function threeWebGLFramebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: number): void
 /** @gea-host-inert Native state only; retains no script references and invokes no script. */
-declare function threeWebGLDrawBuffers(attachment: number): void
+declare function threeWebGLDrawBuffers(count: number, a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7: number): void
 /** @gea-host-inert Copies scalar arguments into GL state; retains no script references and invokes no script. */
 declare function threeWebGLClearColor(r: number, g: number, b: number, a: number): void
 /** @gea-host-inert Native state only; retains no script references and invokes no script. */