@onerjs/smart-filters-blocks 8.25.0

package/src/blocks/babylon/demo/utilities/premultiplyAlphaBlock.block.ts

@@ -0,0 +1,129 @@
+/* eslint-disable prettier/prettier */
+// ************************************************************
+// Note: this file is auto-generated, do not modify it directly
+// ************************************************************
+
+// It was generated by convertGlslIntoBlock() from
+// an annotated .glsl file. Modify the .glsl file to make changes
+// to the block. This file will get overwritten when the build
+// is run or during a watch when the .glsl file is updated.
+
+import type { Effect } from "core/Materials/effect.js";
+
+import {
+    DisableableShaderBinding,
+    type RuntimeData,
+    ConnectionPointType,
+    type SmartFilter,
+    DisableableShaderBlock,
+    type ShaderProgram,
+    type IDisableableBlock,
+    BlockDisableStrategy} from "smart-filters";
+
+/**
+ * The shader program for the block.
+ */
+const BlockShaderProgram: ShaderProgram = {
+    vertex: undefined,
+    fragment: {
+        uniform: `
+            uniform sampler2D _input_; // main`,
+        mainInputTexture: "_input_",
+        mainFunctionName: "_premultiply_",
+        functions: [
+            {
+                name: "_premultiply_",
+                code: `
+                    vec4 _premultiply_(vec2 vUV) { 
+                        vec4 color = texture2D(_input_, vUV);
+                        return vec4(color.rgb * color.a, color.a);
+                    }
+                    `,
+                params: "vec2 vUV",
+            },
+        ],
+    },
+};
+
+/**
+ * The uniform names for this shader, to be used in the shader binding so
+ * that the names are always in sync.
+ */
+const Uniforms = {
+    input: "input",
+};
+
+
+/**
+ * The shader binding for the PremultiplyAlphaBlock, used by the runtime
+ */
+class PremultiplyAlphaBlockShaderBinding extends DisableableShaderBinding {
+    private readonly _input: RuntimeData<ConnectionPointType.Texture>;
+
+    /**
+     * Creates a new shader binding instance for the block.
+     * @param parentBlock - IDisableableBlock
+     * @param input - The input runtime value
+     */
+    constructor(
+        parentBlock: IDisableableBlock,
+        input: RuntimeData<ConnectionPointType.Texture>
+    ) {
+        super(parentBlock);
+        this._input = input;
+    }
+
+    /**
+     * Binds all the required data to the shader when rendering.
+     * @param effect - defines the effect to bind the data to
+     */
+    public override bind(effect: Effect): void {
+        super.bind(effect);
+        effect.setTexture(this.getRemappedName(Uniforms.input), this._input.value);
+    }
+}
+
+/**
+ * The implementation of the PremultiplyAlphaBlock
+ */
+export class PremultiplyAlphaBlock extends DisableableShaderBlock {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "PremultiplyAlphaBlock";
+
+    /**
+     * The namespace of the block.
+     */
+    public static override Namespace = "Babylon.Demo.Utilities";
+
+    /**
+     * The input connection point.
+     */
+    public readonly input = this._registerInput(Uniforms.input, ConnectionPointType.Texture);
+
+    /**
+     * The shader program (vertex and fragment code) to use to render the block
+     */
+    public static override ShaderCode = BlockShaderProgram;
+
+    /**
+     * Instantiates a new PremultiplyAlphaBlock.
+     * @param smartFilter - The smart filter this block belongs to
+     * @param name - The friendly name of the block
+     */
+    constructor(smartFilter: SmartFilter, name: string) {
+        super(smartFilter, name, false, BlockDisableStrategy.AutoSample);
+    }
+
+    /**
+     * Get the class instance that binds all the required data to the shader (effect) when rendering.
+     * @returns The class instance that binds the data to the effect
+     */
+    public getShaderBinding(): DisableableShaderBinding {
+        const input = this._confirmRuntimeDataSupplied(this.input);
+
+        return new PremultiplyAlphaBlockShaderBinding(this,input);
+    }
+}
+

package/src/blocks/blockNamespaces.ts

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+export const babylonDemoEffectsNamespace = "Babylon.Demo.Effects";
+export const babylonDemoUtilitiesNamespace = "Babylon.Demo.Utilities";
+export const babylonDemoTransitionsNamespace = "Babylon.Demo.Transitions";
+export const inputsNamespace = "Inputs";
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/blocks/blockTypes.ts

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+export const pixelateBlockType = "PixelateBlock";
+export const blackAndWhiteBlockType = "BlackAndWhiteBlock";
+export const exposureBlockType = "ExposureBlock";
+export const contrastBlockType = "ContrastBlock";
+export const desaturateBlockType = "DesaturateBlock";
+export const posterizeBlockType = "PosterizeBlock";
+export const kaleidoscopeBlockType = "KaleidoscopeBlock";
+export const greenScreenBlockType = "GreenScreenBlock";
+export const glassBlockType = "GlassBlock";
+export const frameBlockType = "FrameBlock";
+export const blurBlockType = "BlurBlock";
+export const directionalBlurBlockType = "DirectionalBlurBlock";
+export const compositionBlockType = "CompositionBlock";
+export const glitchBlockType = "GlitchBlock";
+export const tileBlockType = "TileBlock";
+export const wipeBlockType = "WipeBlock";
+export const maskBlockType = "MaskBlock";
+export const particleBlockType = "ParticleBlock";
+export const spritesheetBlockType = "SpritesheetBlock";
+export const tintBlockType = "TintBlock";
+export const premultiplyAlphaBlockType = "PremultiplyAlphaBlock";
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/blocks/index.ts

@@ -0,0 +1,6 @@
+/* eslint-disable import/no-internal-modules */
+export * from "./babylon/demo/effects/index.js";
+export * from "./babylon/demo/transitions/index.js";
+export * from "./babylon/demo/utilities/index.js";
+export * from "./blockTypes.js";
+export * from "./blockNamespaces.js";

package/src/index.ts

@@ -0,0 +1,3 @@
+/* eslint-disable import/no-internal-modules */
+export * from "./registration/index.js";
+export * from "./blocks/index.js";

package/src/registration/IBlockRegistration.ts

@@ -0,0 +1,43 @@
+import type { ThinEngine } from "core/Engines/thinEngine.js";
+import type { SmartFilter, SmartFilterDeserializer, ISerializedBlockV1, BaseBlock } from "smart-filters";
+
+/**
+ * An object which describes a block definition, as well as a factory for creating a new instance of the block or
+ * deserializing it
+ */
+export interface IBlockRegistration {
+    /**
+     * The block type of the block
+     */
+    blockType: string;
+
+    /**
+     * Creates an instance of the block, either fresh or deserialized from a serialized block
+     * @param smartFilter - The smart filter to create the block for
+     * @param engine - The engine to use for creating blocks
+     * @param smartFilterDeserializer - The deserializer to use for deserializing blocks
+     * @param serializedBlock - The serialized block to deserialize, if any
+     * @returns - A promise for a new instance of the block
+     */
+    factory?: (smartFilter: SmartFilter, engine: ThinEngine, smartFilterDeserializer: SmartFilterDeserializer, serializedBlock?: ISerializedBlockV1) => Promise<BaseBlock>;
+
+    /**
+     * The namespace of the block
+     */
+    namespace: string;
+
+    /**
+     * A tooltip for the block if displayed in an editor, for instance
+     */
+    tooltip: string;
+
+    /**
+     * True if this is an input block
+     */
+    isInput?: boolean;
+
+    /**
+     * If true, this represents a custom block (not one that was programmatically included)
+     */
+    isCustom?: boolean;
+}

package/src/registration/blockSerializers.ts

@@ -0,0 +1,50 @@
+import type { IBlockSerializerV1 } from "smart-filters";
+import { BlurBlockSerializer } from "../blocks/babylon/demo/effects/blurBlock.serializer.js";
+import { DirectionalBlurBlockSerializer } from "../blocks/babylon/demo/effects/directionalBlurBlock.serializer.js";
+import { CompositionBlockSerializer } from "../blocks/babylon/demo/effects/compositionBlock.serializer.js";
+import {
+    blackAndWhiteBlockType,
+    pixelateBlockType,
+    exposureBlockType,
+    contrastBlockType,
+    desaturateBlockType,
+    posterizeBlockType,
+    kaleidoscopeBlockType,
+    greenScreenBlockType,
+    maskBlockType,
+    particleBlockType,
+    spritesheetBlockType,
+    tintBlockType,
+    premultiplyAlphaBlockType,
+    wipeBlockType,
+} from "../blocks/blockTypes.js";
+
+/**
+ * Any blocks that do not need to make use of ISerializedBlockV1.data can use the default serialization and
+ * should go in this list. If the serializer needs to store additional info in ISerializedBlockV1.data (e.g.
+ * webcam source name), then it should be registered in additionalBlockSerializers below.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const blocksUsingDefaultSerialization: string[] = [
+    blackAndWhiteBlockType,
+    pixelateBlockType,
+    exposureBlockType,
+    contrastBlockType,
+    desaturateBlockType,
+    posterizeBlockType,
+    kaleidoscopeBlockType,
+    greenScreenBlockType,
+    maskBlockType,
+    particleBlockType,
+    spritesheetBlockType,
+    tintBlockType,
+    premultiplyAlphaBlockType,
+    wipeBlockType,
+];
+
+/**
+ * Any blocks which require serializing more information than just the connections should be registered here.
+ * They should make use of the ISerializedBlockV1.data field to store this information.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const additionalBlockSerializers: IBlockSerializerV1[] = [BlurBlockSerializer, DirectionalBlurBlockSerializer, CompositionBlockSerializer];

package/src/registration/builtInBlockRegistrations.ts

@@ -0,0 +1,293 @@
+import type { ThinEngine } from "core/Engines/thinEngine.js";
+import { InputBlock, type SmartFilter, type SmartFilterDeserializer, type ISerializedBlockV1, ConnectionPointType, CustomShaderBlock } from "smart-filters";
+import type { IBlockRegistration } from "./IBlockRegistration.js";
+import { babylonDemoEffectsNamespace, babylonDemoTransitionsNamespace, babylonDemoUtilitiesNamespace, inputsNamespace } from "../blocks/blockNamespaces.js";
+import {
+    blackAndWhiteBlockType,
+    kaleidoscopeBlockType,
+    posterizeBlockType,
+    desaturateBlockType,
+    contrastBlockType,
+    greenScreenBlockType,
+    pixelateBlockType,
+    exposureBlockType,
+    maskBlockType,
+    spritesheetBlockType,
+    premultiplyAlphaBlockType,
+    wipeBlockType,
+    blurBlockType,
+    compositionBlockType,
+    tintBlockType,
+} from "../blocks/blockTypes.js";
+
+/**
+ * The list of block registrations.
+ *
+ * Important notes:
+ *   1. Do not import the block code directly in this file. Instead, use dynamic imports to ensure that the block code
+ *      is only loaded when needed.
+ *   2. If the deserializer is trivial (doesn't require consulting the serializedBlock.data), it can be implemented here
+ *   3. If the deserializer is non-trivial (needs serializedBlock.data), implement it in a separate file alongside the block
+ *      in the form blockClassName.deserializer.ts
+ */
+export const BuiltInBlockRegistrations: IBlockRegistration[] = [
+    // Blocks with trivial deserializers
+    // Note that some choose to predefine corresponding input blocks if not being deserialized
+    // ---------------------------------------------------------------------------------------
+    {
+        blockType: blackAndWhiteBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "blackAndWhiteBlock" */ "../blocks/babylon/demo/effects/blackAndWhiteBlock.block.js");
+            return new module.BlackAndWhiteBlock(smartFilter, serializedBlock?.name || "BlackAndWhite");
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Transform the input texture to black and white",
+    },
+    {
+        blockType: kaleidoscopeBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "kaleidoscopeBlock" */ "../blocks/babylon/demo/effects/kaleidoscopeBlock.js");
+            const block = new module.KaleidoscopeBlock(smartFilter, serializedBlock?.name || "Kaleidoscope");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Angle", ConnectionPointType.Float, 0);
+                input.output.connectTo(block.time);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Kaleidoscope effect",
+    },
+    {
+        blockType: posterizeBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "posterizeBlock" */ "../blocks/babylon/demo/effects/posterizeBlock.block.js");
+            const block = new module.PosterizeBlock(smartFilter, serializedBlock?.name || "Posterize");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Intensity", ConnectionPointType.Float, 0.5);
+                input.output.connectTo(block.intensity);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Posterize to the input texture",
+    },
+    {
+        blockType: desaturateBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "desaturateBlock" */ "../blocks/babylon/demo/effects/desaturateBlock.block.js");
+            const block = new module.DesaturateBlock(smartFilter, serializedBlock?.name || "Desaturate");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Intensity", ConnectionPointType.Float, 0.5);
+                input.output.connectTo(block.intensity);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Applies a desaturated effect to the input texture",
+    },
+    {
+        blockType: contrastBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "contrastBlock" */ "../blocks/babylon/demo/effects/contrastBlock.block.js");
+            const block = new module.ContrastBlock(smartFilter, serializedBlock?.name || "Contrast");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Intensity", ConnectionPointType.Float, 0.5);
+                input.output.connectTo(block.intensity);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Change the contrast of the input texture",
+    },
+    {
+        blockType: greenScreenBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "greenScreenBlock" */ "../blocks/babylon/demo/effects/greenScreenBlock.block.js");
+            const block = new module.GreenScreenBlock(smartFilter, serializedBlock?.name || "GreenScreen");
+            if (!serializedBlock) {
+                const reference = new InputBlock(smartFilter, "Reference", ConnectionPointType.Color3, {
+                    r: 92 / 255,
+                    g: 204 / 255,
+                    b: 78 / 255,
+                });
+                const distance = new InputBlock(smartFilter, "Distance", ConnectionPointType.Float, 0.25);
+                reference.output.connectTo(block.reference);
+                distance.output.connectTo(block.distance);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Replaces a green screen background with a different texture",
+    },
+    {
+        blockType: pixelateBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "pixelateBlock" */ "../blocks/babylon/demo/effects/pixelateBlock.block.js");
+            const block = new module.PixelateBlock(smartFilter, serializedBlock?.name || "Pixelate");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Intensity", ConnectionPointType.Float, 0.4);
+                input.output.connectTo(block.intensity);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Add pixelation to the input texture",
+    },
+    {
+        blockType: exposureBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "exposureBlock" */ "../blocks/babylon/demo/effects/exposureBlock.block.js");
+            const block = new module.ExposureBlock(smartFilter, serializedBlock?.name || "Exposure");
+            if (!serializedBlock) {
+                const input = new InputBlock(smartFilter, "Amount", ConnectionPointType.Float, 0.7);
+                input.output.connectTo(block.amount);
+            }
+            return block;
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Alters the exposure of the input texture",
+    },
+    {
+        blockType: maskBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "maskBlock" */ "../blocks/babylon/demo/effects/maskBlock.block.js");
+            return new module.MaskBlock(smartFilter, serializedBlock?.name || "Mask");
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Applies mask in one texture to another texture",
+    },
+    {
+        blockType: spritesheetBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "spritesheetBlock" */ "../blocks/babylon/demo/effects/spritesheetBlock.js");
+            return new module.SpritesheetBlock(smartFilter, serializedBlock?.name || "Spritesheet");
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Animates a sprite sheet texture",
+    },
+    {
+        blockType: premultiplyAlphaBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "premultiplyAlphaBlock" */ "../blocks/babylon/demo/utilities/premultiplyAlphaBlock.block.js");
+            return new module.PremultiplyAlphaBlock(smartFilter, serializedBlock?.name || "PremultiplyAlpha");
+        },
+        namespace: babylonDemoUtilitiesNamespace,
+        tooltip: "Premultiplies the input texture's color against its alpha",
+    },
+    {
+        blockType: wipeBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "wipeBlock" */ "../blocks/babylon/demo/transitions/wipeBlock.block.js");
+            return new module.WipeBlock(smartFilter, serializedBlock?.name || "Wipe");
+        },
+        namespace: babylonDemoTransitionsNamespace,
+        tooltip: "Transition from one texture to another using a wipe",
+    },
+
+    // Blocks with custom deserializers
+    // --------------------------------
+    {
+        blockType: blurBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            if (serializedBlock) {
+                const module = await import(/* webpackChunkName: "blurBlockDeserializer" */ "../blocks/babylon/demo/effects/blurBlock.deserializer.js");
+                return module.BlurBlockDeserializer(smartFilter, serializedBlock);
+            } else {
+                const module = await import(/* webpackChunkName: "blurBlock" */ "../blocks/babylon/demo/effects/blurBlock.js");
+                return new module.BlurBlock(smartFilter, "Blur");
+            }
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Blur the input texture",
+    },
+    {
+        blockType: compositionBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            if (serializedBlock) {
+                const module = await import(/* webpackChunkName: "compositionBlockDeserializer" */ "../blocks/babylon/demo/effects/compositionBlock.deserializer.js");
+                return module.CompositionDeserializer(smartFilter, serializedBlock);
+            } else {
+                const module = await import(/* webpackChunkName: "compositionBlock" */ "../blocks/babylon/demo/effects/compositionBlock.js");
+                const block = new module.CompositionBlock(smartFilter, "Composition");
+                const top = new InputBlock(smartFilter, "Top", ConnectionPointType.Float, 0.0);
+                const left = new InputBlock(smartFilter, "Left", ConnectionPointType.Float, 0.0);
+                const width = new InputBlock(smartFilter, "Width", ConnectionPointType.Float, 1.0);
+                const height = new InputBlock(smartFilter, "Height", ConnectionPointType.Float, 1.0);
+
+                top.output.connectTo(block.foregroundTop);
+                left.output.connectTo(block.foregroundLeft);
+                width.output.connectTo(block.foregroundWidth);
+                height.output.connectTo(block.foregroundHeight);
+                return block;
+            }
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Composite the foreground texture over the background texture",
+    },
+
+    // Blocks defined by serialized definitions
+    // ----------------------------------------
+    {
+        blockType: tintBlockType,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        factory: async (smartFilter: SmartFilter, _engine: ThinEngine, _smartFilterDeserializer: SmartFilterDeserializer, serializedBlock: ISerializedBlockV1 | undefined) => {
+            const module = await import(/* webpackChunkName: "tintBlock" */ "../blocks/babylon/demo/effects/tintBlock.js");
+            return CustomShaderBlock.Create(smartFilter, serializedBlock?.name || "Tint", module.DeserializedTintBlockDefinition);
+        },
+        namespace: babylonDemoEffectsNamespace,
+        tooltip: "Adds colored tint to the input texture",
+    },
+
+    // Standard input blocks
+    // ---------------------
+    {
+        blockType: "Float",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A floating point number representing a value with a fractional component",
+    },
+    {
+        blockType: "Color3",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A set of 3 floating point numbers representing a color",
+    },
+    {
+        blockType: "Color4",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A set of 4 floating point numbers representing a color",
+    },
+    {
+        blockType: "Texture",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A texture to be used as input",
+    },
+    {
+        blockType: "Vector2",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A Vector2 to be used as input",
+    },
+    {
+        blockType: "Boolean",
+        namespace: inputsNamespace,
+        isInput: true,
+        tooltip: "A boolean to be used as input",
+    },
+];

package/src/registration/index.ts

@@ -0,0 +1,4 @@
+export * from "./builtInBlockRegistrations.js";
+export * from "./IBlockRegistration.js";
+// Back compat for when camelCase was used
+export { BuiltInBlockRegistrations as builtInBlockRegistrations } from "./builtInBlockRegistrations.js";