ris-framework 0.1.0-dev.4

package/src/webgl/buffers/WebGlUniformBuffer.ts

@@ -0,0 +1,87 @@
+import { WebGlUtilities } from "../utilities/WebGlUtilities.ts";
+import type { WebGlGraphicsDevice } from "../WebGlGraphicsDevice.ts";
+import {AlignUtilities, type BufferUsage, type IFramework, type IUniformBuffer} from "ris-framework-api";
+
+/**
+ * The WebGL implementation of the uniform buffer.
+ */
+export class WebGlUniformBuffer implements IUniformBuffer {
+
+    private readonly _gl: WebGL2RenderingContext;
+    private _byteSize: number = 0;
+    private _data: Float32Array;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param dataOrByteSize The data or it's byte size.
+     * @param bufferUsage The buffer usage.
+     * @param label The label to use.
+     */
+    public constructor(framework: IFramework,
+                       dataOrByteSize: ArrayLike<number> | number,
+                       bufferUsage: BufferUsage,
+                       label?: string) {
+
+        this._gl = (framework.renderer.graphicsDevice as WebGlGraphicsDevice).gl;
+        this.usage = bufferUsage;
+        this.label = label;
+
+        if(typeof dataOrByteSize === "number") {
+            this._data = new Float32Array(dataOrByteSize);
+        }
+        else {
+            this._data = new Float32Array(AlignUtilities.alignArray(dataOrByteSize, 4));
+        }
+
+        this._byteSize = this._data.byteLength;
+
+    }
+
+
+    /** 
+     * The native WebGL buffer object that is used to store the uniform data. 
+     */
+    public glBuffer: WebGLBuffer | null = null;
+
+    /** @inheritdoc */
+    public readonly label?: string;
+
+    /** @inheritdoc */
+    public get byteSize(): number {
+        return this._byteSize;
+    }
+
+    /** @inheritdoc */
+    public readonly usage: BufferUsage;
+
+    /** @inheritdoc */
+    public initialize(): void {
+
+        this.glBuffer = WebGlUtilities.buffer.createUniformBuffer(
+            this._gl, this._data, this.usage, this.label);
+    }
+
+
+    /** @inheritdoc */
+    public update(data: number[], offset?: number, length?: number): void {
+        this._gl.bindBuffer(this._gl.UNIFORM_BUFFER, this.glBuffer);
+
+        offset = offset ?? 0;
+        length = length ?? this._data.length;
+        for(let i = offset; i < length; i++)
+        {
+            this._data[i] = data[i];
+        }
+
+        this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, offset ?? 0, this._data);
+    }
+
+    /** @inheritdoc */
+    public dispose(): void {
+        if (this.glBuffer) {
+            this._gl.deleteBuffer(this.glBuffer);
+            this.glBuffer = null;
+        }
+    }
+}

package/src/webgl/buffers/WebGlVertexBuffer.ts

@@ -0,0 +1,100 @@
+import {WebGlUtilities} from "../utilities/WebGlUtilities.ts";
+import type {WebGlGraphicsDevice} from "../WebGlGraphicsDevice.ts";
+import {BufferUsage, type IFramework, type IVertexBuffer} from "ris-framework-api";
+
+/**
+ * The WebGL implementation of the vertex buffer.
+ * This class is responsible for managing a vertex buffer in WebGL,
+ * including creating the buffer, uploading data to the buffer,
+ * and providing information about the buffer such as its size and stride.
+ */
+export class WebGlVertexBuffer implements IVertexBuffer {
+
+    private readonly _graphicsDevice: WebGlGraphicsDevice;
+    private readonly _gl: WebGL2RenderingContext;
+    private _vertexCount = 0;
+    private _byteSize = 0;
+    private _data: Float32Array;
+
+    /**
+     * The constructor.
+     * @param _framework
+     * @param dataOrVertexCount
+     * @param _byteStride
+     * @param _bufferUsage
+     * @param _label
+     */
+    constructor(private readonly _framework: IFramework,
+                dataOrVertexCount: ArrayLike<number> | number,
+                private readonly _byteStride: number,
+                private readonly _bufferUsage: BufferUsage,
+                private readonly _label?: string) {
+        this._graphicsDevice = this._framework.renderer.graphicsDevice as WebGlGraphicsDevice;
+        this._gl = this._graphicsDevice.gl;
+
+        if (typeof dataOrVertexCount === "number") {
+            this._vertexCount = dataOrVertexCount;
+            this._byteSize = dataOrVertexCount * this._byteStride;
+            this._data = new Float32Array(dataOrVertexCount);
+        }
+        // Is iterable
+        else {
+            this._data = new Float32Array(dataOrVertexCount);
+            this._byteSize = dataOrVertexCount.length * Float32Array.BYTES_PER_ELEMENT;
+            this._vertexCount = this._byteSize / this._byteStride;
+        }
+    }
+
+    /**
+     * The WebGL buffer object that represents the vertex buffer in WebGL.
+     */
+    public buffer: WebGLBuffer | null = null;
+
+    /** @inheritdoc */
+    public get label(): string | undefined {
+        return this._label;
+    }
+
+    /** @inheritdoc */
+    public get vertexCount(): number {
+        return this._vertexCount;
+    }
+
+    /** @inheritdoc */
+    public get byteSize(): number {
+        return this._byteSize;
+    }
+
+    /** @inheritdoc */
+    public get byteStride(): number {
+        return this._byteStride;
+    }
+
+    /** @inheritdoc */
+    public get usage(): BufferUsage {
+        return this._bufferUsage;
+    }
+
+    /** @inheritdoc */
+    public initialize(): void {
+        this.buffer = WebGlUtilities.buffer.createVertexBuffer(this._gl, this._data, this._bufferUsage);
+    }
+
+    /** @inheritdoc */
+    public update(data: number[], offset: number = 0, length: number = 0): void {
+
+        length = length > 0 ? length : data.length;
+
+        for (let i = offset; i < length; ++i) {
+            this._data[i] = data[i];
+        }
+
+        WebGlUtilities.buffer.updateVertexBuffer(this._gl, this.buffer!, this._data, 0, offset, length);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+    }
+}

package/src/webgl/buffers/webgl-index-buffer.ts

@@ -0,0 +1,110 @@
+import type {IFramework} from "ris-framework-api";
+import {asWebGLGraphicsDevice} from "../cast/cast";
+import {WebGlUtilities} from "../utilities/WebGlUtilities.ts";
+import {BufferUsage, type IIndexBuffer, IndexBufferType} from "ris-framework-api";
+
+/**
+ * The WebGLIndexBuffer class is an implementation of the IIndexBuffer interface for WebGL.
+ * It represents a buffer that holds index data for rendering in a WebGL context. The class provides properties to access the type, size, and count of indices, as well as a method to initialize the buffer with index data. It also implements the IDisposable interface, allowing it to be disposed of to free resources when it is no longer needed.
+ */
+export class WebGLIndexBuffer implements IIndexBuffer {
+
+    private readonly _gl: WebGL2RenderingContext;
+    private readonly _label?: string;
+
+    private _type = IndexBufferType.UINT_16;
+    private _elementByteSize = 0;
+    private _indicesCount = 0;
+    private _byteSize = 0;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param label An optional label for the index buffer, which can be used for debugging purposes.
+     */
+    constructor(framework: IFramework, label?: string) {
+        this._gl = asWebGLGraphicsDevice(framework.renderer.graphicsDevice).gl;
+        this._label = label;
+        this.usage = BufferUsage.INDEX;
+    }
+
+    /** @inheritdoc */
+    public readonly usage: BufferUsage = BufferUsage.INDEX;
+
+    /**
+     * The WebGL buffer object that represents the index buffer in WebGL.
+     * This buffer is used to store the index data on the GPU and is bound to the appropriate target when rendering.
+     */
+    public buffer: WebGLBuffer | null = null;
+
+    /** @inheritdoc */
+    public get type(): IndexBufferType {
+        return this._type;
+    }
+
+    /** @inheritdoc */
+    public get elementByteSize(): number {
+        return this._elementByteSize;
+    }
+
+    /** @inheritdoc */
+    public get label(): string {
+        return this._label ?? "";
+    }
+
+    /** @inheritdoc */
+    public get indicesCount(): number {
+        return this._indicesCount;
+    }
+
+    /** @inheritdoc */
+    public get byteSize(): number {
+        return this._byteSize;
+    }
+
+    private _canUseUint16(values: ArrayLike<number>): boolean {
+        let max = 0;
+
+        for (let i = 0; i < values.length; i++) {
+            const v = values[i];
+            if (v < 0 || v > 0xFFFF) {
+                return false;
+            }
+            if (v > max) {
+                max = v;
+            }
+        }
+
+        return max <= 0xFFFF;
+    }
+
+    /** @inheritdoc */
+    public initialize(data: ArrayLike<number>): void {
+
+        const typedData = this._canUseUint16(data) ? new Uint16Array(data) : new Uint32Array(data);
+
+        if (typedData instanceof Uint16Array) {
+            this._type = IndexBufferType.UINT_16;
+            this._elementByteSize = Uint16Array.BYTES_PER_ELEMENT;
+        } else if (typedData instanceof Uint32Array) {
+            this._type = IndexBufferType.UINT_32;
+            this._elementByteSize = Uint32Array.BYTES_PER_ELEMENT;
+        } else {
+            throw new Error("Invalid data type for index buffer. Expected Uint16Array or Uint32Array.");
+        }
+
+        this._indicesCount = data.length;
+        this._byteSize = this._indicesCount * this._elementByteSize;
+        this.buffer = WebGlUtilities.buffer.createIndexBuffer(this._gl, typedData, BufferUsage.INDEX, this._label);
+    }
+
+
+     /** @inheritdoc */
+    public dispose(): void {
+      
+        if (this.buffer) {
+            this._gl.deleteBuffer(this.buffer);
+            this.buffer = null;
+        }
+    }
+}

package/src/webgl/cast/cast.ts

@@ -0,0 +1,100 @@
+import type {IBlendState, IIndexBuffer, ITexture2D, IUniformBuffer, IVertexBuffer} from "ris-framework-api";
+import type { ITempRenderer } from "../../core/renderer/renderer-interface";
+import { WebGlBlendState } from "../blending/webgl-blend-state";
+import { WebGLIndexBuffer } from "../buffers/webgl-index-buffer";
+import { WebGlUniformBuffer } from "../buffers/WebGlUniformBuffer.ts";
+import { WebGlVertexBuffer } from "../buffers/WebGlVertexBuffer.ts";
+import { WebGlTexture2D } from "../texture/WebGlTexture2D.ts";
+import { WebGlGraphicsDevice } from "../WebGlGraphicsDevice.ts";
+import { WebGlRenderer } from "../WebGlRenderer.ts";
+
+/**
+ * Casts the given renderer to a WebGLRenderer. If the renderer is not a WebGLRenderer, an error is thrown.
+ * @param renderer The renderer to cast.
+ * @returns The given renderer casted to a WebGLRenderer.
+ */
+export function asWebGLRenderer(renderer: ITempRenderer): WebGlRenderer {
+    if (renderer instanceof WebGlRenderer) {
+        return renderer;
+    } else {
+        throw new Error("Renderer is not a WebGLRenderer.");
+    }
+}
+
+/**
+ * Casts the given texture to a WebGLTexture2D. If the texture is not a WebGLTexture2D, an error is thrown.
+ * @param texture The texture to cast.
+ * @returns The given texture casted to a WebGLTexture2D.
+ */
+export function asWebGLTexture2D(texture: ITexture2D): WebGlTexture2D {
+    if (texture instanceof WebGlTexture2D) {
+        return texture;
+    } else {
+        throw new Error("Texture is not a WebGLTexture2D.");
+    }
+}
+
+/**
+ * Casts the given vertex buffer to a WebGLVertexBuffer. If the vertex buffer is not a WebGLVertexBuffer, an error is thrown.
+ * @param vertexBuffer The vertex buffer to cast.
+ * @returns The given vertex buffer casted to a WebGLVertexBuffer.
+ */
+export function asWebGLVertexBuffer(vertexBuffer: IVertexBuffer): WebGlVertexBuffer {
+    if (vertexBuffer instanceof WebGlVertexBuffer) {
+        return vertexBuffer;
+    } else {
+        throw new Error("Vertex buffer is not a WebGLVertexBuffer.");
+    }
+}
+
+/**
+ * Casts the given index buffer to a WebGLIndexBuffer. If the index buffer is not a WebGLIndexBuffer, an error is thrown.
+ * @param indexBuffer The index buffer to cast.
+ * @returns The given index buffer cast to a WebGLIndexBuffer.
+ */
+export function asWebGLIndexBuffer(indexBuffer: IIndexBuffer): WebGLIndexBuffer {
+    if (indexBuffer instanceof WebGLIndexBuffer) {
+        return indexBuffer;
+    } else {
+        throw new Error("Index buffer is not a WebGLIndexBuffer.");
+    }
+}
+
+/**
+ * Casts the given uniform buffer to a WebGLUniformBuffer. If the uniform buffer is not a WebGLUniformBuffer, an error is thrown.
+ * @param uniformBuffer The uniform buffer to cast.
+ * @returns The given uniform buffer casted to a WebGLUniformBuffer.
+ */
+export function asWebGLUniformBuffer(uniformBuffer: IUniformBuffer): WebGlUniformBuffer {
+    if (uniformBuffer instanceof WebGlUniformBuffer) {
+        return uniformBuffer;
+    } else {
+        throw new Error("Uniform buffer is not a WebGLUniformBuffer.");
+    }
+}
+
+/**
+ * Casts the given graphics device to a WebGLGraphicsDevice. If the graphics device is not a WebGLGraphicsDevice, an error is thrown.
+ * @param graphicsDevice The graphics device to cast.
+ * @returns The given graphics device casted to a WebGLGraphicsDevice.
+ */
+export function asWebGLGraphicsDevice(graphicsDevice: ITempRenderer["graphicsDevice"]): WebGlGraphicsDevice {
+    if (graphicsDevice instanceof WebGlGraphicsDevice   ) {
+        return graphicsDevice as WebGlGraphicsDevice;
+    } else {
+        throw new Error("Graphics device is not a WebGL graphics device.");
+    }   
+}
+
+/**
+ * Casts the given blend state to a WebGLBlendState. If the blend state is not a WebGLBlendState, an error is thrown.
+ * @param blendState The blend state to cast.
+ * @returns The given blend state casted to a WebGLBlendState.
+ */
+export function asWebGLBlendState(blendState: IBlendState): WebGlBlendState {
+    if (blendState instanceof WebGlBlendState) {
+        return blendState as WebGlBlendState;
+    } else {
+        throw new Error("Blend state is not a WebGL blend state.");
+    }
+}

package/src/webgl/primitive/WebGlPrimitiveState.ts

@@ -0,0 +1,60 @@
+import { type PrimitiveTopology, CullMode, type FrontFace } from "../../core/rendering/primitive/enums";
+import type { PrimitiveStateDescriptor } from "../../core/rendering/primitive/PrimitiveStateDescriptor.ts";
+import type { IPrimitiveState } from "ris-framework-api";
+import { WebGlConverter } from "../utilities/WebGlConverter.ts";
+
+/**
+* The WebGL implementation of a primitive state.
+*/
+export class WebGlPrimitiveState implements IPrimitiveState {
+    private readonly _cullingEnabled: boolean;
+    private readonly _glPrimitiveType: number;
+    private readonly _glCullFace: number;
+    private readonly _glFrontFace: number;
+
+    /**
+     * The constructor.
+     * @param _gl The WebGL2 Rendering Context.
+     * @param descriptor The descriptor of the primitive state.
+     */
+    public constructor(_gl: WebGL2RenderingContext, descriptor: PrimitiveStateDescriptor) {
+        this.topology = descriptor.topology;
+        this.cullFace = descriptor.cullFace;
+        this.frontFace = descriptor.frontFace;
+
+        this._cullingEnabled = this.cullFace != CullMode.NONE;
+
+        this._glPrimitiveType = WebGlConverter.convertPrimitiveType(this.topology);
+        this._glCullFace = WebGlConverter.convertCullFace(this.cullFace);
+        this._glFrontFace = WebGlConverter.convertFrontFace(this.frontFace);
+    }
+
+    /** @inheritdoc */
+    public readonly topology: PrimitiveTopology;
+
+    /** @inheritdoc */
+    public readonly cullFace: CullMode;
+
+    /** @inheritdoc */
+    public readonly frontFace: FrontFace;
+
+    /**
+    * The primitive type to draw.
+    */
+    public get glPrimitiveType() {
+        return this._glPrimitiveType;
+    }
+
+    /** @inheritdoc */
+    public apply(gl: WebGL2RenderingContext) {
+        if (this._cullingEnabled) {
+            gl.enable(gl.CULL_FACE);
+            gl.cullFace(this._glCullFace);
+        }
+        else {
+            gl.disable(gl.CULL_FACE);
+        }
+
+        gl.frontFace(this._glFrontFace);
+    }
+}

package/src/webgl/render-pass/WebGlRenderPass.ts

@@ -0,0 +1,186 @@
+import type { IRenderPass } from "../../core/rendering/render-pass/render-pass-interface";
+import { asWebGLTexture2D } from "../cast/cast";
+import { WebGlUtilities } from "../utilities/WebGlUtilities.ts";
+import type { WebGlGraphicsDevice } from "../WebGlGraphicsDevice.ts";
+import {
+    Color,
+    LoadAction,
+    RenderPassColorAttachment, RenderPassDepthStencilAttachment,
+    RenderPassDescriptor,
+    StoreAction,
+    TextureFormat
+} from "ris-framework-api"
+
+/**
+ * The WeGL implementation of the IRenderPass interface. 
+ */
+export class WebGlRenderPass implements IRenderPass {
+
+    private readonly _gl: WebGL2RenderingContext;
+
+    private _colorAttachmentsCount = 0;
+    private _clearColors: Color[] = [];
+    private _frameBuffer: WebGLFramebuffer | null = null;
+    private _depthStencilRenderBuffer: WebGLRenderbuffer | null = null;
+    private _clearBufferMask: GLbitfield = 0;
+    private _enableDepthTest = false;
+    private _enableStencilTest = false;
+    private _clearDepth = 0;
+    private _clearStencil = 0;
+    private _discardAttachments: GLenum[] = [];
+
+    /**
+     * The constructor.
+     * @param graphicsDevice The graphics device.
+     * @param descriptor The render pass descriptor.
+     */
+    public constructor(graphicsDevice: WebGlGraphicsDevice, descriptor: RenderPassDescriptor) {
+        this._gl = graphicsDevice.gl;
+
+        this._setupFrameBuffer(descriptor.colorAttachments ?? []);
+        if (descriptor.depthStencilAttachment) {
+            this._setupDepthStencilAttachment(descriptor.depthStencilAttachment, descriptor.colorAttachments);
+        }
+    }
+
+    private _setupFrameBuffer(colorAttachments: RenderPassColorAttachment[]): void {
+        this._colorAttachmentsCount = colorAttachments.length;
+        this._clearColors = [];
+
+        for (let i = 0; i < this._colorAttachmentsCount; i++) {
+            const colorAttachment = colorAttachments[i];
+            this._clearColors.push(colorAttachment.clearColor);
+            if (colorAttachment.loadAction == LoadAction.CLEAR) {
+                this._clearBufferMask |= this._gl.COLOR_BUFFER_BIT;
+            }
+            if (colorAttachment.storeAction == StoreAction.DISCARD) {
+                this._discardAttachments.push(this._gl.COLOR_ATTACHMENT0 + i);
+            }
+
+            // If the color attachment is a swapchain, we don't need to create a framebuffer,
+            // as we'll be rendering directly to the default framebuffer.
+            if (colorAttachment.swapChain) {
+                this._frameBuffer = null; // Default framebuffer
+                return;
+            }
+        }
+
+        var glColorAttachments = []
+        for (let i = 0; i < this._colorAttachmentsCount; i++) {
+            var colorAttachment = colorAttachments[i];
+            var texture = asWebGLTexture2D(colorAttachment.texture!);
+            if (!texture) {
+                throw new Error("Texture must be provided for non-swapchain color attachments.");
+            }
+
+            glColorAttachments[i] = texture.glTexture;
+        }
+
+        // TODO : pass label
+        this._frameBuffer = WebGlUtilities.framebuffer.create(this._gl, glColorAttachments)
+    }
+
+    private _setupDepthStencilAttachment(depthStencilAttachment?: RenderPassDepthStencilAttachment, colorAttachments: RenderPassColorAttachment[] = []): void {
+
+        if (!depthStencilAttachment) {
+            return;
+        }
+
+        // DEPTH
+        this._clearDepth = depthStencilAttachment.depthClearValue;
+        if (depthStencilAttachment.depthLoadAction == LoadAction.CLEAR) {
+            this._clearBufferMask |= this._gl.DEPTH_BUFFER_BIT;
+            this._enableDepthTest = true;
+        }
+        if (depthStencilAttachment.depthStoreAction == StoreAction.DISCARD) {
+            this._discardAttachments.push(this._gl.DEPTH_ATTACHMENT);
+        }
+
+        // STENCIL
+        this._clearStencil = depthStencilAttachment.stencilClearValue;
+        if (depthStencilAttachment.stencilLoadAction == LoadAction.CLEAR) {
+            this._clearBufferMask |= this._gl.STENCIL_BUFFER_BIT;
+            this._enableStencilTest = true;
+        }
+        if (depthStencilAttachment.stencilStoreAction == StoreAction.DISCARD) {
+            this._discardAttachments.push(this._gl.STENCIL_ATTACHMENT);
+        }
+
+        var texture = depthStencilAttachment.texture;
+
+        // We do allow depth-stencil attachment to be null, in which case the framebuffer will be created with renderbuffers instead of textures.
+        // This is useful for intermediate render passes that don't need to sample from the depth-stencil attachment.
+        if (!texture) {
+            if (this._enableDepthTest || this._enableStencilTest) {
+                var format = TextureFormat.DEPTH_24_STENCIL_8;
+
+                if (!this._enableDepthTest) {
+                    // TODO: Implement this.
+                    throw new Error("Not implemented");
+                }
+                else if (!this._enableStencilTest) {
+                    format = TextureFormat.DEPTH_32_FLOAT;
+                }
+                var colorTex = colorAttachments[0].texture!;
+                this._depthStencilRenderBuffer = WebGlUtilities.renderBuffer.create(this._gl, format, colorTex.width, colorTex.height, null);
+                WebGlUtilities.framebuffer.attachDepthStencilRenderBuffer(this._gl, this._frameBuffer!, this._depthStencilRenderBuffer, format);
+            }
+        }
+        // Otherwise, we attach the provided depth-stencil texture to the framebuffer.
+        else {
+            var glTexture = asWebGLTexture2D(texture);
+            WebGlUtilities.framebuffer.attachDepthStencilTexture(this._gl, this._frameBuffer!, glTexture.glTexture, glTexture.textureFormat);
+        }
+    }
+
+    /** @inheritdoc */
+    public beginPass(): void {
+        const gl = this._gl;
+
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
+        
+        // COLOR
+        gl.clear(this._clearBufferMask);
+
+        if (this._enableDepthTest) {
+            gl.enable(gl.DEPTH_TEST);
+            gl.clearDepth(this._clearDepth);
+            gl.depthFunc(gl.LEQUAL);
+        } else {
+            gl.disable(gl.DEPTH_TEST);
+        }
+
+        if (this._enableStencilTest) {
+            gl.enable(gl.STENCIL_TEST);
+            gl.clearStencil(this._clearStencil);
+            gl.stencilFunc(gl.ALWAYS, 0, 0xFF);
+        } else {
+            gl.disable(gl.STENCIL_TEST);
+        }
+
+        for (let i = 0; i < this._colorAttachmentsCount; i++) {
+            gl.clearBufferfv(gl.COLOR, i, this._clearColors[i]);
+        }
+    }
+
+    /** @inheritdoc */
+    public endPass(): void {
+
+        const gl = this._gl;
+        if (this._discardAttachments.length > 0) {
+            gl.invalidateFramebuffer(gl.FRAMEBUFFER, this._discardAttachments);
+        }
+    }
+
+    /** @inheritdoc */
+    public dispose(): void {
+        if (this._frameBuffer) {
+            this._gl.deleteFramebuffer(this._frameBuffer);
+            this._frameBuffer = null!;
+        }
+        if (this._depthStencilRenderBuffer) {
+            this._gl.deleteRenderbuffer(this._depthStencilRenderBuffer);
+            this._depthStencilRenderBuffer = null;
+        }
+    }
+}