|
|
@@ -17577,6 +17577,238 @@ class VertexColorNode extends AttributeNode {
|
|
|
*/
|
|
|
const vertexColor = ( index = 0 ) => nodeObject( new VertexColorNode( index ) );
|
|
|
|
|
|
+/**
|
|
|
+ * Represents a "Color Burn" blend mode.
|
|
|
+ *
|
|
|
+ * It's designed to darken the base layer's colors based on the color of the blend layer.
|
|
|
+ * It significantly increases the contrast of the base layer, making the colors more vibrant and saturated.
|
|
|
+ * The darker the color in the blend layer, the stronger the darkening and contrast effect on the base layer.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec3>} base - The base color.
|
|
|
+ * @param {Node<vec3>} blend - The blend color. A white (#ffffff) blend color does not alter the base color.
|
|
|
+ * @return {Node<vec3>} The result.
|
|
|
+ */
|
|
|
+const blendBurn = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
+
|
|
|
+ return min$1( 1.0, base.oneMinus().div( blend ) ).oneMinus();
|
|
|
+
|
|
|
+} ).setLayout( {
|
|
|
+ name: 'blendBurn',
|
|
|
+ type: 'vec3',
|
|
|
+ inputs: [
|
|
|
+ { name: 'base', type: 'vec3' },
|
|
|
+ { name: 'blend', type: 'vec3' }
|
|
|
+ ]
|
|
|
+} );
|
|
|
+
|
|
|
+/**
|
|
|
+ * Represents a "Color Dodge" blend mode.
|
|
|
+ *
|
|
|
+ * It's designed to lighten the base layer's colors based on the color of the blend layer.
|
|
|
+ * It significantly increases the brightness of the base layer, making the colors lighter and more vibrant.
|
|
|
+ * The brighter the color in the blend layer, the stronger the lightening and contrast effect on the base layer.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec3>} base - The base color.
|
|
|
+ * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
|
|
|
+ * @return {Node<vec3>} The result.
|
|
|
+ */
|
|
|
+const blendDodge = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
+
|
|
|
+ return min$1( base.div( blend.oneMinus() ), 1.0 );
|
|
|
+
|
|
|
+} ).setLayout( {
|
|
|
+ name: 'blendDodge',
|
|
|
+ type: 'vec3',
|
|
|
+ inputs: [
|
|
|
+ { name: 'base', type: 'vec3' },
|
|
|
+ { name: 'blend', type: 'vec3' }
|
|
|
+ ]
|
|
|
+} );
|
|
|
+
|
|
|
+/**
|
|
|
+ * Represents a "Screen" blend mode.
|
|
|
+ *
|
|
|
+ * Similar to `blendDodge()`, this mode also lightens the base layer's colors based on the color of the blend layer.
|
|
|
+ * The "Screen" blend mode is better for general brightening whereas the "Dodge" results in more subtle and nuanced
|
|
|
+ * effects.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec3>} base - The base color.
|
|
|
+ * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
|
|
|
+ * @return {Node<vec3>} The result.
|
|
|
+ */
|
|
|
+const blendScreen = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
+
|
|
|
+ return base.oneMinus().mul( blend.oneMinus() ).oneMinus();
|
|
|
+
|
|
|
+} ).setLayout( {
|
|
|
+ name: 'blendScreen',
|
|
|
+ type: 'vec3',
|
|
|
+ inputs: [
|
|
|
+ { name: 'base', type: 'vec3' },
|
|
|
+ { name: 'blend', type: 'vec3' }
|
|
|
+ ]
|
|
|
+} );
|
|
|
+
|
|
|
+/**
|
|
|
+ * Represents a "Overlay" blend mode.
|
|
|
+ *
|
|
|
+ * It's designed to increase the contrast of the base layer based on the color of the blend layer.
|
|
|
+ * It amplifies the existing colors and contrast in the base layer, making lighter areas lighter and darker areas darker.
|
|
|
+ * The color of the blend layer significantly influences the resulting contrast and color shift in the base layer.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec3>} base - The base color.
|
|
|
+ * @param {Node<vec3>} blend - The blend color
|
|
|
+ * @return {Node<vec3>} The result.
|
|
|
+ */
|
|
|
+const blendOverlay = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
+
|
|
|
+ return mix( base.mul( 2.0 ).mul( blend ), base.oneMinus().mul( 2.0 ).mul( blend.oneMinus() ).oneMinus(), step( 0.5, base ) );
|
|
|
+
|
|
|
+} ).setLayout( {
|
|
|
+ name: 'blendOverlay',
|
|
|
+ type: 'vec3',
|
|
|
+ inputs: [
|
|
|
+ { name: 'base', type: 'vec3' },
|
|
|
+ { name: 'blend', type: 'vec3' }
|
|
|
+ ]
|
|
|
+} );
|
|
|
+
|
|
|
+/**
|
|
|
+ * This function blends two color based on their alpha values by replicating the behavior of `THREE.NormalBlending`.
|
|
|
+ * It assumes both input colors have non-premultiplied alpha.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec4>} base - The base color.
|
|
|
+ * @param {Node<vec4>} blend - The blend color
|
|
|
+ * @return {Node<vec4>} The result.
|
|
|
+ */
|
|
|
+const blendColor = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
+
|
|
|
+ const outAlpha = blend.a.add( base.a.mul( blend.a.oneMinus() ) );
|
|
|
+
|
|
|
+ return vec4( blend.rgb.mul( blend.a ).add( base.rgb.mul( base.a ).mul( blend.a.oneMinus() ) ).div( outAlpha ), outAlpha );
|
|
|
+
|
|
|
+} ).setLayout( {
|
|
|
+ name: 'blendColor',
|
|
|
+ type: 'vec4',
|
|
|
+ inputs: [
|
|
|
+ { name: 'base', type: 'vec4' },
|
|
|
+ { name: 'blend', type: 'vec4' }
|
|
|
+ ]
|
|
|
+} );
|
|
|
+
|
|
|
+/**
|
|
|
+ * Premultiplies the RGB channels of a color by its alpha channel.
|
|
|
+ *
|
|
|
+ * This function is useful for converting a non-premultiplied alpha color
|
|
|
+ * into a premultiplied alpha format, where the RGB values are scaled
|
|
|
+ * by the alpha value. Premultiplied alpha is often used in graphics
|
|
|
+ * rendering for certain operations, such as compositing and image processing.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec4>} color - The input color with non-premultiplied alpha.
|
|
|
+ * @return {Node<vec4>} The color with premultiplied alpha.
|
|
|
+ */
|
|
|
+const premultiplyAlpha = /*@__PURE__*/ Fn( ( [ color ] ) => {
|
|
|
+
|
|
|
+ return vec4( color.rgb.mul( color.a ), color.a );
|
|
|
+
|
|
|
+}, { color: 'vec4', return: 'vec4' } );
|
|
|
+
|
|
|
+/**
|
|
|
+ * Unpremultiplies the RGB channels of a color by its alpha channel.
|
|
|
+ *
|
|
|
+ * This function is useful for converting a premultiplied alpha color
|
|
|
+ * back into a non-premultiplied alpha format, where the RGB values are
|
|
|
+ * divided by the alpha value. Unpremultiplied alpha is often used in graphics
|
|
|
+ * rendering for certain operations, such as compositing and image processing.
|
|
|
+ *
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @param {Node<vec4>} color - The input color with premultiplied alpha.
|
|
|
+ * @return {Node<vec4>} The color with non-premultiplied alpha.
|
|
|
+ */
|
|
|
+const unpremultiplyAlpha = /*@__PURE__*/ Fn( ( [ color ] ) => {
|
|
|
+
|
|
|
+ If( color.a.equal( 0.0 ), () => vec4( 0.0 ) );
|
|
|
+
|
|
|
+ return vec4( color.rgb.div( color.a ), color.a );
|
|
|
+
|
|
|
+}, { color: 'vec4', return: 'vec4' } );
|
|
|
+
|
|
|
+
|
|
|
+// Deprecated
|
|
|
+
|
|
|
+/**
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @deprecated since r171. Use {@link blendBurn} instead.
|
|
|
+ *
|
|
|
+ * @param {...any} params
|
|
|
+ * @returns {Function}
|
|
|
+ */
|
|
|
+const burn = ( ...params ) => { // @deprecated, r171
|
|
|
+
|
|
|
+ console.warn( 'THREE.TSL: "burn" has been renamed. Use "blendBurn" instead.' );
|
|
|
+ return blendBurn( params );
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @deprecated since r171. Use {@link blendDodge} instead.
|
|
|
+ *
|
|
|
+ * @param {...any} params
|
|
|
+ * @returns {Function}
|
|
|
+ */
|
|
|
+const dodge = ( ...params ) => { // @deprecated, r171
|
|
|
+
|
|
|
+ console.warn( 'THREE.TSL: "dodge" has been renamed. Use "blendDodge" instead.' );
|
|
|
+ return blendDodge( params );
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @deprecated since r171. Use {@link blendScreen} instead.
|
|
|
+ *
|
|
|
+ * @param {...any} params
|
|
|
+ * @returns {Function}
|
|
|
+ */
|
|
|
+const screen = ( ...params ) => { // @deprecated, r171
|
|
|
+
|
|
|
+ console.warn( 'THREE.TSL: "screen" has been renamed. Use "blendScreen" instead.' );
|
|
|
+ return blendScreen( params );
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * @tsl
|
|
|
+ * @function
|
|
|
+ * @deprecated since r171. Use {@link blendOverlay} instead.
|
|
|
+ *
|
|
|
+ * @param {...any} params
|
|
|
+ * @returns {Function}
|
|
|
+ */
|
|
|
+const overlay = ( ...params ) => { // @deprecated, r171
|
|
|
+
|
|
|
+ console.warn( 'THREE.TSL: "overlay" has been renamed. Use "blendOverlay" instead.' );
|
|
|
+ return blendOverlay( params );
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
/**
|
|
|
* Base class for all node materials.
|
|
|
*
|
|
|
@@ -18629,6 +18861,19 @@ class NodeMaterial extends Material {
|
|
|
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * Setups premultiplied alpha.
|
|
|
+ *
|
|
|
+ * @param {NodeBuilder} builder - The current node builder.
|
|
|
+ * @param {Node<vec4>} outputNode - The existing output node.
|
|
|
+ * @return {Node<vec4>} The output node.
|
|
|
+ */
|
|
|
+ setupPremultipliedAlpha( builder, outputNode ) {
|
|
|
+
|
|
|
+ return premultiplyAlpha( outputNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
/**
|
|
|
* Setups the output node.
|
|
|
*
|
|
|
@@ -18646,6 +18891,14 @@ class NodeMaterial extends Material {
|
|
|
|
|
|
}
|
|
|
|
|
|
+ // PREMULTIPLIED ALPHA
|
|
|
+
|
|
|
+ if ( this.premultipliedAlpha === true ) {
|
|
|
+
|
|
|
+ outputNode = this.setupPremultipliedAlpha( builder, outputNode );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
return outputNode;
|
|
|
|
|
|
}
|
|
|
@@ -25986,6 +26239,16 @@ class RenderObject {
|
|
|
*/
|
|
|
this.attributes = null;
|
|
|
|
|
|
+ /**
|
|
|
+ * An object holding the version of the
|
|
|
+ * attributes. The keys are the attribute names
|
|
|
+ * and the values are the attribute versions.
|
|
|
+ *
|
|
|
+ * @type {?Object<string, number>}
|
|
|
+ * @default null
|
|
|
+ */
|
|
|
+ this.attributesId = null;
|
|
|
+
|
|
|
/**
|
|
|
* A reference to a render pipeline the render
|
|
|
* object is processed with.
|
|
|
@@ -26105,7 +26368,7 @@ class RenderObject {
|
|
|
|
|
|
/**
|
|
|
* An event listener which is executed when `dispose()` is called on
|
|
|
- * the render object's material.
|
|
|
+ * the material of this render object.
|
|
|
*
|
|
|
* @method
|
|
|
*/
|
|
|
@@ -26115,7 +26378,23 @@ class RenderObject {
|
|
|
|
|
|
};
|
|
|
|
|
|
+ /**
|
|
|
+ * An event listener which is executed when `dispose()` is called on
|
|
|
+ * the geometry of this render object.
|
|
|
+ *
|
|
|
+ * @method
|
|
|
+ */
|
|
|
+ this.onGeometryDispose = () => {
|
|
|
+
|
|
|
+ // clear geometry cache attributes
|
|
|
+
|
|
|
+ this.attributes = null;
|
|
|
+ this.attributesId = null;
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
this.material.addEventListener( 'dispose', this.onMaterialDispose );
|
|
|
+ this.geometry.addEventListener( 'dispose', this.onGeometryDispose );
|
|
|
|
|
|
}
|
|
|
|
|
|
@@ -26254,6 +26533,7 @@ class RenderObject {
|
|
|
|
|
|
this.geometry = geometry;
|
|
|
this.attributes = null;
|
|
|
+ this.attributesId = null;
|
|
|
|
|
|
}
|
|
|
|
|
|
@@ -26273,9 +26553,25 @@ class RenderObject {
|
|
|
const attributes = [];
|
|
|
const vertexBuffers = new Set();
|
|
|
|
|
|
+ const attributesId = {};
|
|
|
+
|
|
|
for ( const nodeAttribute of nodeAttributes ) {
|
|
|
|
|
|
- const attribute = nodeAttribute.node && nodeAttribute.node.attribute ? nodeAttribute.node.attribute : geometry.getAttribute( nodeAttribute.name );
|
|
|
+ let attribute;
|
|
|
+
|
|
|
+ if ( nodeAttribute.node && nodeAttribute.node.attribute ) {
|
|
|
+
|
|
|
+ // node attribute
|
|
|
+ attribute = nodeAttribute.node.attribute;
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // geometry attribute
|
|
|
+ attribute = geometry.getAttribute( nodeAttribute.name );
|
|
|
+
|
|
|
+ attributesId[ nodeAttribute.name ] = attribute.version;
|
|
|
+
|
|
|
+ }
|
|
|
|
|
|
if ( attribute === undefined ) continue;
|
|
|
|
|
|
@@ -26287,6 +26583,7 @@ class RenderObject {
|
|
|
}
|
|
|
|
|
|
this.attributes = attributes;
|
|
|
+ this.attributesId = attributesId;
|
|
|
this.vertexBuffers = Array.from( vertexBuffers.values() );
|
|
|
|
|
|
return attributes;
|
|
|
@@ -26551,7 +26848,27 @@ class RenderObject {
|
|
|
*/
|
|
|
get needsGeometryUpdate() {
|
|
|
|
|
|
- return this.geometry.id !== this.object.geometry.id;
|
|
|
+ if ( this.geometry.id !== this.object.geometry.id ) return true;
|
|
|
+
|
|
|
+ if ( this.attributes !== null ) {
|
|
|
+
|
|
|
+ const attributesId = this.attributesId;
|
|
|
+
|
|
|
+ for ( const name in attributesId ) {
|
|
|
+
|
|
|
+ const attribute = this.geometry.getAttribute( name );
|
|
|
+
|
|
|
+ if ( attribute === undefined || attributesId[ name ] !== attribute.id ) {
|
|
|
+
|
|
|
+ return true;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
|
|
|
}
|
|
|
|
|
|
@@ -26629,6 +26946,7 @@ class RenderObject {
|
|
|
dispose() {
|
|
|
|
|
|
this.material.removeEventListener( 'dispose', this.onMaterialDispose );
|
|
|
+ this.geometry.removeEventListener( 'dispose', this.onGeometryDispose );
|
|
|
|
|
|
this.onDispose();
|
|
|
|
|
|
@@ -33550,238 +33868,6 @@ function getPreviousMatrix( object, index = 0 ) {
|
|
|
*/
|
|
|
const velocity = /*@__PURE__*/ nodeImmutable( VelocityNode );
|
|
|
|
|
|
-/**
|
|
|
- * Represents a "Color Burn" blend mode.
|
|
|
- *
|
|
|
- * It's designed to darken the base layer's colors based on the color of the blend layer.
|
|
|
- * It significantly increases the contrast of the base layer, making the colors more vibrant and saturated.
|
|
|
- * The darker the color in the blend layer, the stronger the darkening and contrast effect on the base layer.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec3>} base - The base color.
|
|
|
- * @param {Node<vec3>} blend - The blend color. A white (#ffffff) blend color does not alter the base color.
|
|
|
- * @return {Node<vec3>} The result.
|
|
|
- */
|
|
|
-const blendBurn = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
-
|
|
|
- return min$1( 1.0, base.oneMinus().div( blend ) ).oneMinus();
|
|
|
-
|
|
|
-} ).setLayout( {
|
|
|
- name: 'blendBurn',
|
|
|
- type: 'vec3',
|
|
|
- inputs: [
|
|
|
- { name: 'base', type: 'vec3' },
|
|
|
- { name: 'blend', type: 'vec3' }
|
|
|
- ]
|
|
|
-} );
|
|
|
-
|
|
|
-/**
|
|
|
- * Represents a "Color Dodge" blend mode.
|
|
|
- *
|
|
|
- * It's designed to lighten the base layer's colors based on the color of the blend layer.
|
|
|
- * It significantly increases the brightness of the base layer, making the colors lighter and more vibrant.
|
|
|
- * The brighter the color in the blend layer, the stronger the lightening and contrast effect on the base layer.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec3>} base - The base color.
|
|
|
- * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
|
|
|
- * @return {Node<vec3>} The result.
|
|
|
- */
|
|
|
-const blendDodge = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
-
|
|
|
- return min$1( base.div( blend.oneMinus() ), 1.0 );
|
|
|
-
|
|
|
-} ).setLayout( {
|
|
|
- name: 'blendDodge',
|
|
|
- type: 'vec3',
|
|
|
- inputs: [
|
|
|
- { name: 'base', type: 'vec3' },
|
|
|
- { name: 'blend', type: 'vec3' }
|
|
|
- ]
|
|
|
-} );
|
|
|
-
|
|
|
-/**
|
|
|
- * Represents a "Screen" blend mode.
|
|
|
- *
|
|
|
- * Similar to `blendDodge()`, this mode also lightens the base layer's colors based on the color of the blend layer.
|
|
|
- * The "Screen" blend mode is better for general brightening whereas the "Dodge" results in more subtle and nuanced
|
|
|
- * effects.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec3>} base - The base color.
|
|
|
- * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
|
|
|
- * @return {Node<vec3>} The result.
|
|
|
- */
|
|
|
-const blendScreen = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
-
|
|
|
- return base.oneMinus().mul( blend.oneMinus() ).oneMinus();
|
|
|
-
|
|
|
-} ).setLayout( {
|
|
|
- name: 'blendScreen',
|
|
|
- type: 'vec3',
|
|
|
- inputs: [
|
|
|
- { name: 'base', type: 'vec3' },
|
|
|
- { name: 'blend', type: 'vec3' }
|
|
|
- ]
|
|
|
-} );
|
|
|
-
|
|
|
-/**
|
|
|
- * Represents a "Overlay" blend mode.
|
|
|
- *
|
|
|
- * It's designed to increase the contrast of the base layer based on the color of the blend layer.
|
|
|
- * It amplifies the existing colors and contrast in the base layer, making lighter areas lighter and darker areas darker.
|
|
|
- * The color of the blend layer significantly influences the resulting contrast and color shift in the base layer.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec3>} base - The base color.
|
|
|
- * @param {Node<vec3>} blend - The blend color
|
|
|
- * @return {Node<vec3>} The result.
|
|
|
- */
|
|
|
-const blendOverlay = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
-
|
|
|
- return mix( base.mul( 2.0 ).mul( blend ), base.oneMinus().mul( 2.0 ).mul( blend.oneMinus() ).oneMinus(), step( 0.5, base ) );
|
|
|
-
|
|
|
-} ).setLayout( {
|
|
|
- name: 'blendOverlay',
|
|
|
- type: 'vec3',
|
|
|
- inputs: [
|
|
|
- { name: 'base', type: 'vec3' },
|
|
|
- { name: 'blend', type: 'vec3' }
|
|
|
- ]
|
|
|
-} );
|
|
|
-
|
|
|
-/**
|
|
|
- * This function blends two color based on their alpha values by replicating the behavior of `THREE.NormalBlending`.
|
|
|
- * It assumes both input colors have non-premultiplied alpha.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec4>} base - The base color.
|
|
|
- * @param {Node<vec4>} blend - The blend color
|
|
|
- * @return {Node<vec4>} The result.
|
|
|
- */
|
|
|
-const blendColor = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
|
|
|
-
|
|
|
- const outAlpha = blend.a.add( base.a.mul( blend.a.oneMinus() ) );
|
|
|
-
|
|
|
- return vec4( blend.rgb.mul( blend.a ).add( base.rgb.mul( base.a ).mul( blend.a.oneMinus() ) ).div( outAlpha ), outAlpha );
|
|
|
-
|
|
|
-} ).setLayout( {
|
|
|
- name: 'blendColor',
|
|
|
- type: 'vec4',
|
|
|
- inputs: [
|
|
|
- { name: 'base', type: 'vec4' },
|
|
|
- { name: 'blend', type: 'vec4' }
|
|
|
- ]
|
|
|
-} );
|
|
|
-
|
|
|
-/**
|
|
|
- * Premultiplies the RGB channels of a color by its alpha channel.
|
|
|
- *
|
|
|
- * This function is useful for converting a non-premultiplied alpha color
|
|
|
- * into a premultiplied alpha format, where the RGB values are scaled
|
|
|
- * by the alpha value. Premultiplied alpha is often used in graphics
|
|
|
- * rendering for certain operations, such as compositing and image processing.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec4>} color - The input color with non-premultiplied alpha.
|
|
|
- * @return {Node<vec4>} The color with premultiplied alpha.
|
|
|
- */
|
|
|
-const premult = /*@__PURE__*/ Fn( ( [ color ] ) => {
|
|
|
-
|
|
|
- return vec4( color.rgb.mul( color.a ), color.a );
|
|
|
-
|
|
|
-}, { color: 'vec4', return: 'vec4' } );
|
|
|
-
|
|
|
-/**
|
|
|
- * Unpremultiplies the RGB channels of a color by its alpha channel.
|
|
|
- *
|
|
|
- * This function is useful for converting a premultiplied alpha color
|
|
|
- * back into a non-premultiplied alpha format, where the RGB values are
|
|
|
- * divided by the alpha value. Unpremultiplied alpha is often used in graphics
|
|
|
- * rendering for certain operations, such as compositing and image processing.
|
|
|
- *
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @param {Node<vec4>} color - The input color with premultiplied alpha.
|
|
|
- * @return {Node<vec4>} The color with non-premultiplied alpha.
|
|
|
- */
|
|
|
-const unpremult = /*@__PURE__*/ Fn( ( [ color ] ) => {
|
|
|
-
|
|
|
- If( color.a.equal( 0.0 ), () => vec4( 0.0 ) );
|
|
|
-
|
|
|
- return vec4( color.rgb.div( color.a ), color.a );
|
|
|
-
|
|
|
-}, { color: 'vec4', return: 'vec4' } );
|
|
|
-
|
|
|
-
|
|
|
-// Deprecated
|
|
|
-
|
|
|
-/**
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @deprecated since r171. Use {@link blendBurn} instead.
|
|
|
- *
|
|
|
- * @param {...any} params
|
|
|
- * @returns {Function}
|
|
|
- */
|
|
|
-const burn = ( ...params ) => { // @deprecated, r171
|
|
|
-
|
|
|
- console.warn( 'THREE.TSL: "burn" has been renamed. Use "blendBurn" instead.' );
|
|
|
- return blendBurn( params );
|
|
|
-
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @deprecated since r171. Use {@link blendDodge} instead.
|
|
|
- *
|
|
|
- * @param {...any} params
|
|
|
- * @returns {Function}
|
|
|
- */
|
|
|
-const dodge = ( ...params ) => { // @deprecated, r171
|
|
|
-
|
|
|
- console.warn( 'THREE.TSL: "dodge" has been renamed. Use "blendDodge" instead.' );
|
|
|
- return blendDodge( params );
|
|
|
-
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @deprecated since r171. Use {@link blendScreen} instead.
|
|
|
- *
|
|
|
- * @param {...any} params
|
|
|
- * @returns {Function}
|
|
|
- */
|
|
|
-const screen = ( ...params ) => { // @deprecated, r171
|
|
|
-
|
|
|
- console.warn( 'THREE.TSL: "screen" has been renamed. Use "blendScreen" instead.' );
|
|
|
- return blendScreen( params );
|
|
|
-
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * @tsl
|
|
|
- * @function
|
|
|
- * @deprecated since r171. Use {@link blendOverlay} instead.
|
|
|
- *
|
|
|
- * @param {...any} params
|
|
|
- * @returns {Function}
|
|
|
- */
|
|
|
-const overlay = ( ...params ) => { // @deprecated, r171
|
|
|
-
|
|
|
- console.warn( 'THREE.TSL: "overlay" has been renamed. Use "blendOverlay" instead.' );
|
|
|
- return blendOverlay( params );
|
|
|
-
|
|
|
-};
|
|
|
-
|
|
|
/**
|
|
|
* Computes a grayscale value for the given RGB color value.
|
|
|
*
|
|
|
@@ -41996,7 +42082,7 @@ var TSL = /*#__PURE__*/Object.freeze({
|
|
|
pow2: pow2,
|
|
|
pow3: pow3,
|
|
|
pow4: pow4,
|
|
|
- premult: premult,
|
|
|
+ premultiplyAlpha: premultiplyAlpha,
|
|
|
property: property,
|
|
|
radians: radians,
|
|
|
rand: rand,
|
|
|
@@ -42119,7 +42205,7 @@ var TSL = /*#__PURE__*/Object.freeze({
|
|
|
uniformGroup: uniformGroup,
|
|
|
uniformTexture: uniformTexture,
|
|
|
uniforms: uniforms,
|
|
|
- unpremult: unpremult,
|
|
|
+ unpremultiplyAlpha: unpremultiplyAlpha,
|
|
|
userData: userData,
|
|
|
uv: uv,
|
|
|
uvec2: uvec2,
|
|
|
@@ -61573,7 +61659,7 @@ class WebGLBackend extends Backend {
|
|
|
|
|
|
if ( vaoGPU === undefined ) {
|
|
|
|
|
|
- this._createVao( attributes );
|
|
|
+ this.vaoCache[ vaoKey ] = this._createVao( attributes );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
@@ -61609,7 +61695,7 @@ class WebGLBackend extends Backend {
|
|
|
|
|
|
const dualAttributeData = transformBuffers[ i ];
|
|
|
|
|
|
- if ( dualAttributeData.pbo ) {
|
|
|
+ if ( dualAttributeData.pbo && this.has( dualAttributeData.pbo ) ) {
|
|
|
|
|
|
this.textureUtils.copyBufferToTexture( dualAttributeData.transformBuffer, dualAttributeData.pbo );
|
|
|
|
|
|
@@ -61691,28 +61777,23 @@ class WebGLBackend extends Backend {
|
|
|
|
|
|
// vertex state
|
|
|
|
|
|
- const renderObjectData = this.get( renderObject );
|
|
|
+ const attributes = renderObject.getAttributes();
|
|
|
+ const attributesData = this.get( attributes );
|
|
|
|
|
|
- let vaoGPU = renderObjectData.staticVao;
|
|
|
+ let vaoGPU = attributesData.vaoGPU;
|
|
|
|
|
|
- if ( vaoGPU === undefined || renderObjectData.geometryId !== renderObject.geometry.id ) {
|
|
|
+ if ( vaoGPU === undefined ) {
|
|
|
|
|
|
- const vaoKey = this._getVaoKey( renderObject.getAttributes() );
|
|
|
+ const vaoKey = this._getVaoKey( attributes );
|
|
|
|
|
|
vaoGPU = this.vaoCache[ vaoKey ];
|
|
|
|
|
|
if ( vaoGPU === undefined ) {
|
|
|
|
|
|
- let staticVao;
|
|
|
-
|
|
|
- ( { vaoGPU, staticVao } = this._createVao( renderObject.getAttributes() ) );
|
|
|
-
|
|
|
- if ( staticVao ) {
|
|
|
+ vaoGPU = this._createVao( attributes );
|
|
|
|
|
|
- renderObjectData.staticVao = vaoGPU;
|
|
|
- renderObjectData.geometryId = renderObject.geometry.id;
|
|
|
-
|
|
|
- }
|
|
|
+ this.vaoCache[ vaoKey ] = vaoGPU;
|
|
|
+ attributesData.vaoGPU = vaoGPU;
|
|
|
|
|
|
}
|
|
|
|
|
|
@@ -63012,9 +63093,6 @@ class WebGLBackend extends Backend {
|
|
|
const { gl } = this;
|
|
|
|
|
|
const vaoGPU = gl.createVertexArray();
|
|
|
- let key = '';
|
|
|
-
|
|
|
- let staticVao = true;
|
|
|
|
|
|
gl.bindVertexArray( vaoGPU );
|
|
|
|
|
|
@@ -63023,13 +63101,9 @@ class WebGLBackend extends Backend {
|
|
|
const attribute = attributes[ i ];
|
|
|
const attributeData = this.get( attribute );
|
|
|
|
|
|
- key += ':' + attributeData.id;
|
|
|
-
|
|
|
gl.bindBuffer( gl.ARRAY_BUFFER, attributeData.bufferGPU );
|
|
|
gl.enableVertexAttribArray( i );
|
|
|
|
|
|
- if ( attribute.isStorageBufferAttribute || attribute.isStorageInstancedBufferAttribute ) staticVao = false;
|
|
|
-
|
|
|
let stride, offset;
|
|
|
|
|
|
if ( attribute.isInterleavedBufferAttribute === true ) {
|
|
|
@@ -63068,9 +63142,7 @@ class WebGLBackend extends Backend {
|
|
|
|
|
|
gl.bindBuffer( gl.ARRAY_BUFFER, null );
|
|
|
|
|
|
- this.vaoCache[ key ] = vaoGPU;
|
|
|
-
|
|
|
- return { vaoGPU, staticVao };
|
|
|
+ return vaoGPU;
|
|
|
|
|
|
}
|
|
|
|
sunag