import { __decorate } from "../../../../tslib.es6.js";
import { NodeRenderGraphBaseObjectRendererBlock } from "./baseObjectRendererBlock.js";
import { RegisterClass } from "../../../../Misc/typeStore.js";
import { NodeRenderGraphBlockConnectionPointTypes } from "../../Types/nodeRenderGraphTypes.js";
import { editableInPropertyPage } from "../../../../Decorators/nodeDecorator.js";
import { FrameGraphGeometryRendererTask } from "../../../Tasks/Rendering/geometryRendererTask.js";

/**
 * Block that render geometry of objects to a multi render target
 */
export class NodeRenderGraphGeometryRendererBlock extends NodeRenderGraphBaseObjectRendererBlock {
    /**
     * Gets the frame graph task associated with this block
     */
    get task() {
        return this._frameGraphTask;
    }
    /**
     * Create a new NodeRenderGraphGeometryRendererBlock
     * @param name defines the block name
     * @param frameGraph defines the hosting frame graph
     * @param scene defines the hosting scene
     * @param doNotChangeAspectRatio True (default) to not change the aspect ratio of the scene in the RTT
     * @param enableClusteredLights True (default) to enable clustered lights
     */
    constructor(name, frameGraph, scene, doNotChangeAspectRatio = true, enableClusteredLights = true) {
        super(name, frameGraph, scene);
        // View depth
        this.viewDepthFormat = 6;
        this.viewDepthType = 1;
        // Normalized view depth
        this.normalizedViewDepthFormat = 6;
        this.normalizedViewDepthType = 2;
        // Screen depth
        this.screenDepthFormat = 6;
        this.screenDepthType = 1;
        // View normal
        this.viewNormalFormat = 5;
        this.viewNormalType = 2;
        // World normal
        this.worldNormalFormat = 5;
        this.worldNormalType = 0;
        // Local position
        this.localPositionFormat = 5;
        this.localPositionType = 2;
        // World Position
        this.worldPositionFormat = 5;
        this.worldPositionType = 2;
        // Albedo
        this.albedoFormat = 5;
        this.albedoType = 0;
        // Reflectivity
        this.reflectivityFormat = 5;
        this.reflectivityType = 0;
        // Velocity
        this.velocityFormat = 5;
        this.velocityType = 0;
        // Linear velocity
        this.linearVelocityFormat = 5;
        this.linearVelocityType = 2;
        this.getInputByName("target").isOptional = true;
        this.registerOutput("geomViewDepth", NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth);
        this.registerOutput("geomNormViewDepth", NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth);
        this.registerOutput("geomScreenDepth", NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth);
        this.registerOutput("geomViewNormal", NodeRenderGraphBlockConnectionPointTypes.TextureViewNormal);
        this.registerOutput("geomWorldNormal", NodeRenderGraphBlockConnectionPointTypes.TextureWorldNormal);
        this.registerOutput("geomLocalPosition", NodeRenderGraphBlockConnectionPointTypes.TextureLocalPosition);
        this.registerOutput("geomWorldPosition", NodeRenderGraphBlockConnectionPointTypes.TextureWorldPosition);
        this.registerOutput("geomAlbedo", NodeRenderGraphBlockConnectionPointTypes.TextureAlbedo);
        this.registerOutput("geomReflectivity", NodeRenderGraphBlockConnectionPointTypes.TextureReflectivity);
        this.registerOutput("geomVelocity", NodeRenderGraphBlockConnectionPointTypes.TextureVelocity);
        this.registerOutput("geomLinearVelocity", NodeRenderGraphBlockConnectionPointTypes.TextureLinearVelocity);
        this._frameGraphTask = new FrameGraphGeometryRendererTask(this.name, frameGraph, scene, { doNotChangeAspectRatio, enableClusteredLights });
    }
    _createFrameGraphObject() {
        this._frameGraphTask?.dispose();
        this._frameGraphTask = new FrameGraphGeometryRendererTask(this.name, this._frameGraph, this._scene, {
            doNotChangeAspectRatio: this._additionalConstructionParameters[0],
            enableClusteredLights: this._additionalConstructionParameters[1],
        });
    }
    _saveState(state) {
        super._saveState(state);
        state.disabled = this._frameGraphTask.disabled;
        state.isMainObjectRenderer = this.isMainObjectRenderer;
        state.depthTest = this.depthTest;
        state.depthWrite = this.depthWrite;
        state.disableShadows = this.disableShadows;
        state.renderInLinearSpace = this.renderInLinearSpace;
        state.renderParticles = this.renderParticles;
        state.renderSprites = this.renderSprites;
        state.forceLayerMaskCheck = this.forceLayerMaskCheck;
        state.enableBoundingBoxRendering = this.enableBoundingBoxRendering;
        state.enableOutlineRendering = this.enableOutlineRendering;
        state.width = this.width;
        state.height = this.height;
        state.sizeInPercentage = this.sizeInPercentage;
        state.samples = this.samples;
        state.reverseCulling = this.reverseCulling;
        state.dontRenderWhenMaterialDepthWriteIsDisabled = this.dontRenderWhenMaterialDepthWriteIsDisabled;
        state.disableDepthPrePass = this.disableDepthPrePass;
    }
    _restoreState(state) {
        super._restoreState(state);
        this._frameGraphTask.disabled = state.disabled;
        this.isMainObjectRenderer = state.isMainObjectRenderer;
        this.depthTest = state.depthTest;
        this.depthWrite = state.depthWrite;
        this.disableShadows = state.disableShadows;
        this.renderInLinearSpace = state.renderInLinearSpace;
        this.renderParticles = state.renderParticles;
        this.renderSprites = state.renderSprites;
        this.forceLayerMaskCheck = state.forceLayerMaskCheck;
        this.enableBoundingBoxRendering = state.enableBoundingBoxRendering;
        this.enableOutlineRendering = state.enableOutlineRendering;
        this.width = state.width;
        this.height = state.height;
        this.sizeInPercentage = state.sizeInPercentage;
        this.samples = state.samples;
        this.reverseCulling = state.reverseCulling;
        this.dontRenderWhenMaterialDepthWriteIsDisabled = state.dontRenderWhenMaterialDepthWriteIsDisabled;
        this.disableDepthPrePass = state.disableDepthPrePass;
    }
    /** Width of the geometry texture */
    get width() {
        return this._frameGraphTask.size.width;
    }
    set width(value) {
        this._frameGraphTask.size.width = value;
    }
    /** Height of the geometry texture */
    get height() {
        return this._frameGraphTask.size.height;
    }
    set height(value) {
        this._frameGraphTask.size.height = value;
    }
    /** Indicates if the geometry texture width and height are percentages or absolute values */
    get sizeInPercentage() {
        return this._frameGraphTask.sizeIsPercentage;
    }
    set sizeInPercentage(value) {
        this._frameGraphTask.sizeIsPercentage = value;
    }
    /** Number of samples of the geometry texture */
    get samples() {
        return this._frameGraphTask.samples;
    }
    set samples(value) {
        this._frameGraphTask.samples = value;
    }
    /** Indicates if culling must be reversed */
    get reverseCulling() {
        return this._frameGraphTask.reverseCulling;
    }
    set reverseCulling(value) {
        this._frameGraphTask.reverseCulling = value;
    }
    /** Indicates if a mesh shouldn't be rendered when its material has depth write disabled */
    get dontRenderWhenMaterialDepthWriteIsDisabled() {
        return this._frameGraphTask.dontRenderWhenMaterialDepthWriteIsDisabled;
    }
    set dontRenderWhenMaterialDepthWriteIsDisabled(value) {
        this._frameGraphTask.dontRenderWhenMaterialDepthWriteIsDisabled = value;
    }
    /** Indicates if depth pre-pass must be disabled */
    get disableDepthPrePass() {
        return this._frameGraphTask.disableDepthPrePass;
    }
    set disableDepthPrePass(value) {
        this._frameGraphTask.disableDepthPrePass = value;
    }
    /**
     * Gets the current class name
     * @returns the class name
     */
    getClassName() {
        return "NodeRenderGraphGeometryRendererBlock";
    }
    /**
     * Gets the geometry view depth component
     */
    get geomViewDepth() {
        return this._outputs[3];
    }
    /**
     * Gets the geometry normalized view depth component
     */
    get geomNormViewDepth() {
        return this._outputs[4];
    }
    /**
     * Gets the geometry screen depth component
     */
    get geomScreenDepth() {
        return this._outputs[5];
    }
    /**
     * Gets the geometry view normal component
     */
    get geomViewNormal() {
        return this._outputs[6];
    }
    /**
     * Gets the world geometry normal component
     */
    get geomWorldNormal() {
        return this._outputs[7];
    }
    /**
     * Gets the geometry local position component
     */
    get geomLocalPosition() {
        return this._outputs[8];
    }
    /**
     * Gets the geometry world position component
     */
    get geomWorldPosition() {
        return this._outputs[9];
    }
    /**
     * Gets the geometry albedo component
     */
    get geomAlbedo() {
        return this._outputs[10];
    }
    /**
     * Gets the geometry reflectivity component
     */
    get geomReflectivity() {
        return this._outputs[11];
    }
    /**
     * Gets the geometry velocity component
     */
    get geomVelocity() {
        return this._outputs[12];
    }
    /**
     * Gets the geometry linear velocity component
     */
    get geomLinearVelocity() {
        return this._outputs[13];
    }
    _buildBlock(state) {
        super._buildBlock(state);
        const textureActivation = [
            this.geomViewDepth.isConnected,
            this.geomNormViewDepth.isConnected,
            this.geomScreenDepth.isConnected,
            this.geomViewNormal.isConnected,
            this.geomWorldNormal.isConnected,
            this.geomLocalPosition.isConnected,
            this.geomWorldPosition.isConnected,
            this.geomAlbedo.isConnected,
            this.geomReflectivity.isConnected,
            this.geomVelocity.isConnected,
            this.geomLinearVelocity.isConnected,
        ];
        this.geomViewDepth.value = this._frameGraphTask.geometryViewDepthTexture;
        this.geomNormViewDepth.value = this._frameGraphTask.geometryNormViewDepthTexture;
        this.geomScreenDepth.value = this._frameGraphTask.geometryScreenDepthTexture;
        this.geomViewNormal.value = this._frameGraphTask.geometryViewNormalTexture;
        this.geomWorldNormal.value = this._frameGraphTask.geometryWorldNormalTexture;
        this.geomLocalPosition.value = this._frameGraphTask.geometryLocalPositionTexture;
        this.geomWorldPosition.value = this._frameGraphTask.geometryWorldPositionTexture;
        this.geomAlbedo.value = this._frameGraphTask.geometryAlbedoTexture;
        this.geomReflectivity.value = this._frameGraphTask.geometryReflectivityTexture;
        this.geomVelocity.value = this._frameGraphTask.geometryVelocityTexture;
        this.geomLinearVelocity.value = this._frameGraphTask.geometryLinearVelocityTexture;
        this._frameGraphTask.textureDescriptions = [];
        const textureFormats = [
            this.viewDepthFormat,
            this.normalizedViewDepthFormat,
            this.screenDepthFormat,
            this.viewNormalFormat,
            this.worldNormalFormat,
            this.localPositionFormat,
            this.worldPositionFormat,
            this.albedoFormat,
            this.reflectivityFormat,
            this.velocityFormat,
            this.linearVelocityFormat,
        ];
        const textureTypes = [
            this.viewDepthType,
            this.normalizedViewDepthType,
            this.screenDepthType,
            this.viewNormalType,
            this.worldNormalType,
            this.localPositionType,
            this.worldPositionType,
            this.albedoType,
            this.reflectivityType,
            this.velocityType,
            this.linearVelocityType,
        ];
        const bufferTypes = [
            5,
            13,
            10,
            6,
            8,
            9,
            1,
            12,
            3,
            2,
            11,
        ];
        for (let i = 0; i < textureActivation.length; i++) {
            if (textureActivation[i]) {
                this._frameGraphTask.textureDescriptions.push({
                    textureFormat: textureFormats[i],
                    textureType: textureTypes[i],
                    type: bufferTypes[i],
                });
            }
        }
    }
    _dumpPropertiesCode() {
        const codes = [];
        codes.push(`${this._codeVariableName}.size = { width: ${this.width}, height: ${this.height} };`);
        codes.push(`${this._codeVariableName}.sizeInPercentage = ${this.sizeInPercentage};`);
        codes.push(`${this._codeVariableName}.samples = ${this.samples};`);
        codes.push(`${this._codeVariableName}.reverseCulling = ${this.reverseCulling};`);
        codes.push(`${this._codeVariableName}.dontRenderWhenMaterialDepthWriteIsDisabled = ${this.dontRenderWhenMaterialDepthWriteIsDisabled};`);
        codes.push(`${this._codeVariableName}.disableDepthPrePass = ${this.disableDepthPrePass};`);
        codes.push(`${this._codeVariableName}.viewDepthFormat = ${this.viewDepthFormat};`);
        codes.push(`${this._codeVariableName}.viewDepthType = ${this.viewDepthType};`);
        codes.push(`${this._codeVariableName}.normalizedViewDepthFormat = ${this.normalizedViewDepthFormat};`);
        codes.push(`${this._codeVariableName}.normalizedViewDepthType = ${this.normalizedViewDepthType};`);
        codes.push(`${this._codeVariableName}.screenDepthFormat = ${this.screenDepthFormat};`);
        codes.push(`${this._codeVariableName}.screenDepthType = ${this.screenDepthType};`);
        codes.push(`${this._codeVariableName}.localPositionFormat = ${this.localPositionFormat};`);
        codes.push(`${this._codeVariableName}.localPositionType = ${this.localPositionType};`);
        codes.push(`${this._codeVariableName}.worldPositionFormat = ${this.worldPositionFormat};`);
        codes.push(`${this._codeVariableName}.worldPositionType = ${this.worldPositionType};`);
        codes.push(`${this._codeVariableName}.viewNormalFormat = ${this.viewNormalFormat};`);
        codes.push(`${this._codeVariableName}.viewNormalType = ${this.viewNormalType};`);
        codes.push(`${this._codeVariableName}.worldNormalFormat = ${this.worldNormalFormat};`);
        codes.push(`${this._codeVariableName}.worldNormalType = ${this.worldNormalType};`);
        codes.push(`${this._codeVariableName}.albedoFormat = ${this.albedoFormat};`);
        codes.push(`${this._codeVariableName}.albedoType = ${this.albedoType};`);
        codes.push(`${this._codeVariableName}.reflectivityFormat = ${this.reflectivityFormat};`);
        codes.push(`${this._codeVariableName}.reflectivityType = ${this.reflectivityType};`);
        codes.push(`${this._codeVariableName}.velocityFormat = ${this.velocityFormat};`);
        codes.push(`${this._codeVariableName}.velocityType = ${this.velocityType};`);
        codes.push(`${this._codeVariableName}.linearVelocityFormat = ${this.linearVelocityFormat};`);
        codes.push(`${this._codeVariableName}.linearVelocityType = ${this.linearVelocityType};`);
        return super._dumpPropertiesCode() + codes.join("\n");
    }
    serialize() {
        const serializationObject = super.serialize();
        serializationObject.sizeInPercentage = this.sizeInPercentage;
        serializationObject.width = this.width;
        serializationObject.height = this.height;
        serializationObject.samples = this.samples;
        serializationObject.reverseCulling = this.reverseCulling;
        serializationObject.dontRenderWhenMaterialDepthWriteIsDisabled = this.dontRenderWhenMaterialDepthWriteIsDisabled;
        serializationObject.disableDepthPrePass = this.disableDepthPrePass;
        serializationObject.viewDepthFormat = this.viewDepthFormat;
        serializationObject.viewDepthType = this.viewDepthType;
        serializationObject.normalizedViewDepthFormat = this.normalizedViewDepthFormat;
        serializationObject.normalizedViewDepthType = this.normalizedViewDepthType;
        serializationObject.screenDepthFormat = this.screenDepthFormat;
        serializationObject.screenDepthType = this.screenDepthType;
        serializationObject.localPositionFormat = this.localPositionFormat;
        serializationObject.localPositionType = this.localPositionType;
        serializationObject.worldPositionFormat = this.worldPositionFormat;
        serializationObject.worldPositionType = this.worldPositionType;
        serializationObject.viewNormalFormat = this.viewNormalFormat;
        serializationObject.viewNormalType = this.viewNormalType;
        serializationObject.worldNormalFormat = this.worldNormalFormat;
        serializationObject.worldNormalType = this.worldNormalType;
        serializationObject.albedoFormat = this.albedoFormat;
        serializationObject.albedoType = this.albedoType;
        serializationObject.reflectivityFormat = this.reflectivityFormat;
        serializationObject.reflectivityType = this.reflectivityType;
        serializationObject.velocityFormat = this.velocityFormat;
        serializationObject.velocityType = this.velocityType;
        serializationObject.linearVelocityFormat = this.linearVelocityFormat;
        serializationObject.linearVelocityType = this.linearVelocityType;
        return serializationObject;
    }
    _deserialize(serializationObject) {
        super._deserialize(serializationObject);
        this.sizeInPercentage = !!serializationObject.sizeInPercentage;
        this.width = serializationObject.width ?? 100;
        this.height = serializationObject.height ?? 100;
        this.samples = serializationObject.samples;
        this.reverseCulling = serializationObject.reverseCulling;
        this.dontRenderWhenMaterialDepthWriteIsDisabled = serializationObject.dontRenderWhenMaterialDepthWriteIsDisabled;
        this.disableDepthPrePass = serializationObject.disableDepthPrePass ?? true;
        this.viewDepthFormat = serializationObject.viewDepthFormat;
        this.viewDepthType = serializationObject.viewDepthType;
        this.normalizedViewDepthFormat = serializationObject.normalizedViewDepthFormat ?? 6;
        this.normalizedViewDepthType = serializationObject.normalizedViewDepthType ?? 0;
        this.screenDepthFormat = serializationObject.screenDepthFormat;
        this.screenDepthType = serializationObject.screenDepthType;
        this.localPositionFormat = serializationObject.localPositionFormat;
        this.localPositionType = serializationObject.localPositionType;
        this.worldPositionFormat = serializationObject.worldPositionFormat;
        this.worldPositionType = serializationObject.worldPositionType;
        this.viewNormalFormat = serializationObject.viewNormalFormat;
        this.viewNormalType = serializationObject.viewNormalType;
        this.worldNormalFormat = serializationObject.worldNormalFormat;
        this.worldNormalType = serializationObject.worldNormalType;
        this.albedoFormat = serializationObject.albedoFormat;
        this.albedoType = serializationObject.albedoType;
        this.reflectivityFormat = serializationObject.reflectivityFormat;
        this.reflectivityType = serializationObject.reflectivityType;
        this.velocityFormat = serializationObject.velocityFormat;
        this.velocityType = serializationObject.velocityType;
        this.linearVelocityFormat = serializationObject.linearVelocityFormat;
        this.linearVelocityType = serializationObject.linearVelocityType;
    }
}
__decorate([
    editableInPropertyPage("Texture width", 2 /* PropertyTypeForEdition.Int */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "width", null);
__decorate([
    editableInPropertyPage("Texture height", 2 /* PropertyTypeForEdition.Int */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "height", null);
__decorate([
    editableInPropertyPage("Size is in percentage", 0 /* PropertyTypeForEdition.Boolean */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "sizeInPercentage", null);
__decorate([
    editableInPropertyPage("Samples", 2 /* PropertyTypeForEdition.Int */, "RENDERING - GEOMETRY", { min: 1, max: 8 })
], NodeRenderGraphGeometryRendererBlock.prototype, "samples", null);
__decorate([
    editableInPropertyPage("Reverse culling", 0 /* PropertyTypeForEdition.Boolean */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "reverseCulling", null);
__decorate([
    editableInPropertyPage("Don't render if material depth write is disabled", 0 /* PropertyTypeForEdition.Boolean */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "dontRenderWhenMaterialDepthWriteIsDisabled", null);
__decorate([
    editableInPropertyPage("Disable depth pre-pass", 0 /* PropertyTypeForEdition.Boolean */, "RENDERING - GEOMETRY")
], NodeRenderGraphGeometryRendererBlock.prototype, "disableDepthPrePass", null);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - VIEW DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "viewDepthFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - VIEW DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "viewDepthType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - NORMALIZED VIEW DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "normalizedViewDepthFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - NORMALIZED VIEW DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "normalizedViewDepthType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - SCREEN DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "screenDepthFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - SCREEN DEPTH")
], NodeRenderGraphGeometryRendererBlock.prototype, "screenDepthType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - VIEW NORMAL")
], NodeRenderGraphGeometryRendererBlock.prototype, "viewNormalFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - VIEW NORMAL")
], NodeRenderGraphGeometryRendererBlock.prototype, "viewNormalType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - WORLD NORMAL")
], NodeRenderGraphGeometryRendererBlock.prototype, "worldNormalFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - WORLD NORMAL")
], NodeRenderGraphGeometryRendererBlock.prototype, "worldNormalType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - LOCAL POSITION")
], NodeRenderGraphGeometryRendererBlock.prototype, "localPositionFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - LOCAL POSITION")
], NodeRenderGraphGeometryRendererBlock.prototype, "localPositionType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - WORLD POSITION")
], NodeRenderGraphGeometryRendererBlock.prototype, "worldPositionFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - WORLD POSITION")
], NodeRenderGraphGeometryRendererBlock.prototype, "worldPositionType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - ALBEDO")
], NodeRenderGraphGeometryRendererBlock.prototype, "albedoFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - ALBEDO")
], NodeRenderGraphGeometryRendererBlock.prototype, "albedoType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - REFLECTIVITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "reflectivityFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - REFLECTIVITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "reflectivityType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - VELOCITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "velocityFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - VELOCITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "velocityType", void 0);
__decorate([
    editableInPropertyPage("Format", 9 /* PropertyTypeForEdition.TextureFormat */, "OUTPUT - LINEAR VELOCITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "linearVelocityFormat", void 0);
__decorate([
    editableInPropertyPage("Type", 10 /* PropertyTypeForEdition.TextureType */, "OUTPUT - LINEAR VELOCITY")
], NodeRenderGraphGeometryRendererBlock.prototype, "linearVelocityType", void 0);
RegisterClass("BABYLON.NodeRenderGraphGeometryRendererBlock", NodeRenderGraphGeometryRendererBlock);
//# sourceMappingURL=geometryRendererBlock.js.map