agora-electron-sdk 4.3.2 → 4.4.0-dev.1

package/js/Renderer/RendererCache.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RendererCache = exports.generateRendererCacheKey = void 0;
-var Utils_1 = require("../Utils");
-function generateRendererCacheKey(_a) {
-    var channelId = _a.channelId, uid = _a.uid, sourceType = _a.sourceType;
-    return "".concat(channelId, "_").concat(uid, "_").concat(sourceType);
+const Utils_1 = require("../Utils");
+function generateRendererCacheKey({ channelId, uid, sourceType, }) {
+    return `${channelId}_${uid}_${sourceType}`;
 }
 exports.generateRendererCacheKey = generateRendererCacheKey;
-var RendererCache = /** @class */ (function () {
-    function RendererCache(_a) {
-        var channelId = _a.channelId, uid = _a.uid, sourceType = _a.sourceType;
+class RendererCache {
+    constructor({ channelId, uid, sourceType }) {
         this._renderers = [];
         this._videoFrame = {
             yBuffer: Buffer.alloc(0),
@@ -22,97 +20,68 @@ var RendererCache = /** @class */ (function () {
             vStride: 0,
             rotation: 0,
         };
-        this._context = { channelId: channelId, uid: uid, sourceType: sourceType };
+        this._context = { channelId, uid, sourceType };
         this._enabled = false;
     }
-    Object.defineProperty(RendererCache.prototype, "key", {
-        get: function () {
-            return generateRendererCacheKey(this._context);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "renderers", {
-        get: function () {
-            return this._renderers;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "videoFrame", {
-        get: function () {
-            return this._videoFrame;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "context", {
-        get: function () {
-            return this._context;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "renders", {
-        /**
-         * @deprecated Use renderers instead
-         */
-        get: function () {
-            return this.renderers;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "shareVideoFrame", {
-        /**
-         * @deprecated Use videoFrame instead
-         */
-        get: function () {
-            return this.videoFrame;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RendererCache.prototype, "bridge", {
-        get: function () {
-            return Utils_1.AgoraEnv.AgoraElectronBridge;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RendererCache.prototype.enable = function () {
+    get key() {
+        return generateRendererCacheKey(this._context);
+    }
+    get renderers() {
+        return this._renderers;
+    }
+    get videoFrame() {
+        return this._videoFrame;
+    }
+    get context() {
+        return this._context;
+    }
+    /**
+     * @deprecated Use renderers instead
+     */
+    get renders() {
+        return this.renderers;
+    }
+    /**
+     * @deprecated Use videoFrame instead
+     */
+    get shareVideoFrame() {
+        return this.videoFrame;
+    }
+    get bridge() {
+        return Utils_1.AgoraEnv.AgoraElectronBridge;
+    }
+    enable() {
         if (this._enabled)
             return;
         this.bridge.EnableVideoFrameCache(this._context);
         this._enabled = true;
-    };
-    RendererCache.prototype.disable = function () {
+    }
+    disable() {
         if (!this._enabled)
             return;
         this.bridge.DisableVideoFrameCache(this._context);
         this._enabled = false;
-    };
-    RendererCache.prototype.shouldEnable = function () {
+    }
+    shouldEnable() {
         if (this.renderers.length > 0) {
             this.enable();
         }
         else {
             this.disable();
         }
-    };
-    RendererCache.prototype.draw = function () {
-        var _this = this;
-        var _a = this.bridge.GetVideoFrame(this.context, this.videoFrame), ret = _a.ret, isNewFrame = _a.isNewFrame;
+    }
+    draw() {
+        let { ret, isNewFrame } = this.bridge.GetVideoFrame(this.context, this.videoFrame);
         switch (ret) {
             case 0: // GET_VIDEO_FRAME_CACHE_RETURN_TYPE::OK = 0
                 //
                 break;
             case 1: // GET_VIDEO_FRAME_CACHE_RETURN_TYPE::RESIZED = 1
-                var _b = this.videoFrame, yStride = _b.yStride, uStride = _b.uStride, vStride = _b.vStride, height = _b.height;
+                const { yStride, uStride, vStride, height } = this.videoFrame;
                 this.videoFrame.yBuffer = Buffer.alloc(yStride * height);
                 this.videoFrame.uBuffer = Buffer.alloc(uStride * height);
                 this.videoFrame.vBuffer = Buffer.alloc(vStride * height);
-                var result = this.bridge.GetVideoFrame(this.context, this.videoFrame);
+                const result = this.bridge.GetVideoFrame(this.context, this.videoFrame);
                 ret = result.ret;
                 isNewFrame = result.isNewFrame;
                 break;
@@ -121,50 +90,48 @@ var RendererCache = /** @class */ (function () {
                 return;
         }
         if (isNewFrame) {
-            this.renderers.forEach(function (renderer) {
-                renderer.drawFrame(_this.videoFrame);
+            this.renderers.forEach((renderer) => {
+                renderer.drawFrame(this.videoFrame);
             });
         }
-    };
-    RendererCache.prototype.findRenderer = function (view) {
-        return this._renderers.find(function (renderer) { return renderer.parentElement === view; });
-    };
-    RendererCache.prototype.addRenderer = function (renderer) {
+    }
+    findRenderer(view) {
+        return this._renderers.find((renderer) => renderer.parentElement === view);
+    }
+    addRenderer(renderer) {
         this._renderers.push(renderer);
         this.shouldEnable();
-    };
+    }
     /**
      * Remove the specified renderer if it is specified, otherwise remove all renderers
      */
-    RendererCache.prototype.removeRenderer = function (renderer) {
-        var start = 0;
-        var deleteCount = this._renderers.length;
+    removeRenderer(renderer) {
+        let start = 0;
+        let deleteCount = this._renderers.length;
         if (renderer) {
             start = this._renderers.indexOf(renderer);
             if (start < 0)
                 return;
             deleteCount = 1;
         }
-        this._renderers.splice(start, deleteCount).forEach(function (it) { return it.unbind(); });
+        this._renderers.splice(start, deleteCount).forEach((it) => it.unbind());
         this.shouldEnable();
-    };
-    RendererCache.prototype.setRendererContext = function (_a) {
-        var view = _a.view, renderMode = _a.renderMode, mirrorMode = _a.mirrorMode;
+    }
+    setRendererContext({ view, renderMode, mirrorMode, }) {
         if (view) {
-            var renderer = this.findRenderer(view);
+            const renderer = this.findRenderer(view);
             if (renderer) {
-                renderer.context = { renderMode: renderMode, mirrorMode: mirrorMode };
+                renderer.context = { renderMode, mirrorMode };
                 return true;
             }
             return false;
         }
         else {
-            this._renderers.forEach(function (it) {
-                it.context = { renderMode: renderMode, mirrorMode: mirrorMode };
+            this._renderers.forEach((it) => {
+                it.context = { renderMode, mirrorMode };
             });
             return this._renderers.length > 0;
         }
-    };
-    return RendererCache;
-}());
+    }
+}
 exports.RendererCache = RendererCache;

package/js/Renderer/RendererManager.js

@@ -1,84 +1,52 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RendererManager = void 0;
-var Types_1 = require("../Types");
-var Utils_1 = require("../Utils");
-var IRendererManager_1 = require("./IRendererManager");
-var WebGLRenderer_1 = require("./WebGLRenderer");
-var YUVCanvasRenderer_1 = require("./YUVCanvasRenderer");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const IRendererManager_1 = require("./IRendererManager");
+const WebGLRenderer_1 = require("./WebGLRenderer");
+const YUVCanvasRenderer_1 = require("./YUVCanvasRenderer");
 /**
  * @ignore
  */
-var RendererManager = /** @class */ (function (_super) {
-    __extends(RendererManager, _super);
-    function RendererManager() {
-        var _this = _super.call(this) || this;
-        _this._rendererType = (0, Utils_1.isSupportWebGL)()
+class RendererManager extends IRendererManager_1.IRendererManager {
+    set rendererType(rendererType) {
+        if (this._rendererType !== rendererType) {
+            this._rendererType = rendererType;
+        }
+    }
+    get rendererType() {
+        return this._rendererType;
+    }
+    constructor() {
+        super();
+        this._rendererType = (0, Utils_1.isSupportWebGL)()
             ? Types_1.RendererType.WEBGL
             : Types_1.RendererType.SOFTWARE;
-        return _this;
     }
-    Object.defineProperty(RendererManager.prototype, "rendererType", {
-        get: function () {
-            return this._rendererType;
-        },
-        set: function (rendererType) {
-            if (this._rendererType !== rendererType) {
-                this._rendererType = rendererType;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * @deprecated Use rendererType instead
      */
-    RendererManager.prototype.setRenderMode = function (mode) {
+    setRenderMode(mode) {
         this.rendererType = mode;
-    };
+    }
     /**
      * @deprecated Use renderingFps instead
      */
-    RendererManager.prototype.setFPS = function (fps) {
+    setFPS(fps) {
         this.renderingFps = fps;
-    };
+    }
     /**
      * @deprecated Use getRendererCache instead
      */
-    RendererManager.prototype.getRender = function (context) {
+    getRender(context) {
         return this.getRendererCache(context);
-    };
-    RendererManager.prototype.createRenderer = function (context, rendererType) {
+    }
+    createRenderer(context, rendererType) {
         if (rendererType === undefined) {
             rendererType = this.rendererType;
         }
-        var renderer;
+        let renderer;
         switch (rendererType) {
             case Types_1.RendererType.WEBGL:
                 renderer = new WebGLRenderer_1.WebGLRenderer(this.handleWebGLFallback(context).bind(this));
@@ -95,20 +63,18 @@ var RendererManager = /** @class */ (function (_super) {
             mirrorMode: context.mirrorMode,
         };
         return renderer;
-    };
-    RendererManager.prototype.doRendering = function (rendererCache) {
+    }
+    doRendering(rendererCache) {
         rendererCache.draw();
-    };
-    RendererManager.prototype.handleWebGLFallback = function (context) {
-        var _this = this;
-        return function (renderer) {
-            var _a = renderer.context, renderMode = _a.renderMode, mirrorMode = _a.mirrorMode;
-            var renderers = _this.getRenderers(context);
+    }
+    handleWebGLFallback(context) {
+        return (renderer) => {
+            const { context: { renderMode, mirrorMode }, } = renderer;
+            const renderers = this.getRenderers(context);
             renderer.unbind();
-            var newRenderer = _this.createRenderer(__assign(__assign({}, context), { renderMode: renderMode, mirrorMode: mirrorMode }), Types_1.RendererType.SOFTWARE);
+            const newRenderer = this.createRenderer({ ...context, renderMode, mirrorMode }, Types_1.RendererType.SOFTWARE);
             renderers.splice(renderers.indexOf(renderer), 1, newRenderer);
         };
-    };
-    return RendererManager;
-}(IRendererManager_1.IRendererManager));
+    }
+}
 exports.RendererManager = RendererManager;

package/js/Renderer/WebGLRenderer/index.js

@@ -1,25 +1,10 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebGLRenderer = void 0;
-var Utils_1 = require("../../Utils");
-var IRenderer_1 = require("../IRenderer");
-var createProgramFromSources = require('./webgl-utils').createProgramFromSources;
-var vertexShaderSource = 'attribute vec2 a_position;' +
+const Utils_1 = require("../../Utils");
+const IRenderer_1 = require("../IRenderer");
+const createProgramFromSources = require('./webgl-utils').createProgramFromSources;
+const vertexShaderSource = 'attribute vec2 a_position;' +
     'attribute vec2 a_texCoord;' +
     'uniform vec2 u_resolution;' +
     'varying vec2 v_texCoord;' +
@@ -30,7 +15,7 @@ var vertexShaderSource = 'attribute vec2 a_position;' +
     '   gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);' +
     'v_texCoord = a_texCoord;' +
     '}';
-var yuvShaderSource = 'precision mediump float;' +
+const yuvShaderSource = 'precision mediump float;' +
     'uniform sampler2D Ytex;' +
     'uniform sampler2D Utex;' +
     'uniform sampler2D Vtex;' +
@@ -51,50 +36,42 @@ var yuvShaderSource = 'precision mediump float;' +
     '  b=y+2.017*u;' +
     '  gl_FragColor=vec4(r,g,b,1.0);' +
     '}';
-var WebGLRenderer = /** @class */ (function (_super) {
-    __extends(WebGLRenderer, _super);
-    function WebGLRenderer(fallback) {
-        var _this = _super.call(this) || this;
-        _this.handleContextLost = function (event) {
-            var _a;
+class WebGLRenderer extends IRenderer_1.IRenderer {
+    constructor(fallback) {
+        super();
+        this.handleContextLost = (event) => {
             event.preventDefault();
             (0, Utils_1.logWarn)('webglcontextlost', event);
-            _this.releaseTextures();
-            (_a = _this.fallback) === null || _a === void 0 ? void 0 : _a.call(null, _this, new Error('Browser not support! No WebGL detected.'));
+            this.releaseTextures();
+            this.fallback?.call(null, this, new Error('Browser not support! No WebGL detected.'));
         };
-        _this.handleContextRestored = function (event) {
-            var _a;
+        this.handleContextRestored = (event) => {
             event.preventDefault();
             (0, Utils_1.logWarn)('webglcontextrestored', event);
             // Setup GLSL program
-            _this.program = createProgramFromSources(_this.gl, [
+            this.program = createProgramFromSources(this.gl, [
                 vertexShaderSource,
                 yuvShaderSource,
             ]);
-            (_a = _this.gl) === null || _a === void 0 ? void 0 : _a.useProgram(_this.program);
-            _this.initTextures();
+            this.gl?.useProgram(this.program);
+            this.initTextures();
         };
-        _this.gl = undefined;
-        _this.yTexture = null;
-        _this.uTexture = null;
-        _this.vTexture = null;
-        _this.texCoordBuffer = null;
-        _this.surfaceBuffer = null;
-        _this.fallback = fallback;
-        return _this;
+        this.gl = undefined;
+        this.yTexture = null;
+        this.uTexture = null;
+        this.vTexture = null;
+        this.texCoordBuffer = null;
+        this.surfaceBuffer = null;
+        this.fallback = fallback;
     }
-    WebGLRenderer.prototype.bind = function (view) {
-        var _this = this;
-        var _a, _b, _c, _d;
-        _super.prototype.bind.call(this, view);
-        (_a = this.canvas) === null || _a === void 0 ? void 0 : _a.addEventListener('webglcontextlost', this.handleContextLost, false);
-        (_b = this.canvas) === null || _b === void 0 ? void 0 : _b.addEventListener('webglcontextrestored', this.handleContextRestored, false);
-        var getContext = function (contextNames) {
-            var _a;
-            if (contextNames === void 0) { contextNames = ['webgl2', 'webgl', 'experimental-webgl']; }
-            for (var i = 0; i < contextNames.length; i++) {
-                var contextName = contextNames[i];
-                var context = (_a = _this.canvas) === null || _a === void 0 ? void 0 : _a.getContext(contextName, {
+    bind(view) {
+        super.bind(view);
+        this.canvas?.addEventListener('webglcontextlost', this.handleContextLost, false);
+        this.canvas?.addEventListener('webglcontextrestored', this.handleContextRestored, false);
+        const getContext = (contextNames = ['webgl2', 'webgl', 'experimental-webgl']) => {
+            for (let i = 0; i < contextNames.length; i++) {
+                const contextName = contextNames[i];
+                const context = this.canvas?.getContext(contextName, {
                     depth: true,
                     stencil: true,
                     alpha: false,
@@ -110,9 +87,9 @@ var WebGLRenderer = /** @class */ (function (_super) {
             }
             return null;
         };
-        (_c = this.gl) !== null && _c !== void 0 ? _c : (this.gl = getContext());
+        this.gl ?? (this.gl = getContext());
         if (!this.gl) {
-            (_d = this.fallback) === null || _d === void 0 ? void 0 : _d.call(null, this, new Error('Browser not support! No WebGL detected.'));
+            this.fallback?.call(null, this, new Error('Browser not support! No WebGL detected.'));
             return;
         }
         // Set clear color to black, fully opaque
@@ -132,25 +109,23 @@ var WebGLRenderer = /** @class */ (function (_super) {
         ]);
         this.gl.useProgram(this.program);
         this.initTextures();
-    };
-    WebGLRenderer.prototype.unbind = function () {
-        var _a, _b;
-        (_a = this.canvas) === null || _a === void 0 ? void 0 : _a.removeEventListener('webglcontextlost', this.handleContextLost, false);
-        (_b = this.canvas) === null || _b === void 0 ? void 0 : _b.removeEventListener('webglcontextrestored', this.handleContextRestored, false);
+    }
+    unbind() {
+        this.canvas?.removeEventListener('webglcontextlost', this.handleContextLost, false);
+        this.canvas?.removeEventListener('webglcontextrestored', this.handleContextRestored, false);
         this.releaseTextures();
         this.gl = undefined;
-        _super.prototype.unbind.call(this);
-    };
-    WebGLRenderer.prototype.drawFrame = function (_a) {
-        var width = _a.width, height = _a.height, yStride = _a.yStride, uStride = _a.uStride, vStride = _a.vStride, yBuffer = _a.yBuffer, uBuffer = _a.uBuffer, vBuffer = _a.vBuffer, rotation = _a.rotation;
-        this.rotateCanvas({ width: width, height: height, rotation: rotation });
+        super.unbind();
+    }
+    drawFrame({ width, height, yStride, uStride, vStride, yBuffer, uBuffer, vBuffer, rotation, }) {
+        this.rotateCanvas({ width, height, rotation });
         this.updateRenderMode();
         if (!this.gl || !this.program)
             return;
-        var left = 0, top = 0, right = yStride - width, bottom = 0;
+        const left = 0, top = 0, right = yStride - width, bottom = 0;
         this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.texCoordBuffer);
-        var xWidth = width + left + right;
-        var xHeight = height + top + bottom;
+        const xWidth = width + left + right;
+        const xHeight = height + top + bottom;
         this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array([
             left / xWidth,
             bottom / xHeight,
@@ -180,11 +155,10 @@ var WebGLRenderer = /** @class */ (function (_super) {
         this.gl.bindTexture(this.gl.TEXTURE_2D, this.vTexture);
         this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.LUMINANCE, vStride, height / 2, 0, this.gl.LUMINANCE, this.gl.UNSIGNED_BYTE, vBuffer);
         this.gl.drawArrays(this.gl.TRIANGLES, 0, 6);
-        _super.prototype.drawFrame.call(this);
-    };
-    WebGLRenderer.prototype.rotateCanvas = function (_a) {
-        var width = _a.width, height = _a.height, rotation = _a.rotation;
-        _super.prototype.rotateCanvas.call(this, { width: width, height: height, rotation: rotation });
+        super.drawFrame();
+    }
+    rotateCanvas({ width, height, rotation }) {
+        super.rotateCanvas({ width, height, rotation });
         if (!this.gl)
             return;
         this.gl.viewport(0, 0, width, height);
@@ -196,11 +170,11 @@ var WebGLRenderer = /** @class */ (function (_super) {
         // 90: 2,3,1/1,3,4
         // 180: 3,4,2/2,4,1
         // 270: 4,1,3/3,1,2
-        var p1 = { x: 0, y: 0 };
-        var p2 = { x: width, y: 0 };
-        var p3 = { x: width, y: height };
-        var p4 = { x: 0, y: height };
-        var pp1 = p1, pp2 = p2, pp3 = p3, pp4 = p4;
+        const p1 = { x: 0, y: 0 };
+        const p2 = { x: width, y: 0 };
+        const p3 = { x: width, y: height };
+        const p4 = { x: 0, y: height };
+        let pp1 = p1, pp2 = p2, pp3 = p3, pp4 = p4;
         switch (rotation) {
             case 0:
                 break;
@@ -238,58 +212,55 @@ var WebGLRenderer = /** @class */ (function (_super) {
             pp3.x,
             pp3.y,
         ]), this.gl.STATIC_DRAW);
-        var resolutionLocation = this.gl.getUniformLocation(this.program, 'u_resolution');
+        const resolutionLocation = this.gl.getUniformLocation(this.program, 'u_resolution');
         this.gl.uniform2f(resolutionLocation, width, height);
-    };
-    WebGLRenderer.prototype.initTextures = function () {
-        var _this = this;
+    }
+    initTextures() {
         if (!this.gl)
             return;
         this.positionLocation = this.gl.getAttribLocation(this.program, 'a_position');
         this.texCoordLocation = this.gl.getAttribLocation(this.program, 'a_texCoord');
         this.surfaceBuffer = this.gl.createBuffer();
         this.texCoordBuffer = this.gl.createBuffer();
-        var createTexture = function (textureIndex) {
-            if (!_this.gl)
+        const createTexture = (textureIndex) => {
+            if (!this.gl)
                 return null;
             // Create a texture.
-            _this.gl.activeTexture(textureIndex);
-            var texture = _this.gl.createTexture();
-            _this.gl.bindTexture(_this.gl.TEXTURE_2D, texture);
+            this.gl.activeTexture(textureIndex);
+            const texture = this.gl.createTexture();
+            this.gl.bindTexture(this.gl.TEXTURE_2D, texture);
             // Set the parameters so we can render any size
-            _this.gl.texParameteri(_this.gl.TEXTURE_2D, _this.gl.TEXTURE_WRAP_S, _this.gl.CLAMP_TO_EDGE);
-            _this.gl.texParameteri(_this.gl.TEXTURE_2D, _this.gl.TEXTURE_WRAP_T, _this.gl.CLAMP_TO_EDGE);
-            _this.gl.texParameteri(_this.gl.TEXTURE_2D, _this.gl.TEXTURE_MIN_FILTER, _this.gl.NEAREST);
-            _this.gl.texParameteri(_this.gl.TEXTURE_2D, _this.gl.TEXTURE_MAG_FILTER, _this.gl.NEAREST);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.NEAREST);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
             return texture;
         };
         this.yTexture = createTexture(this.gl.TEXTURE0);
         this.uTexture = createTexture(this.gl.TEXTURE1);
         this.vTexture = createTexture(this.gl.TEXTURE2);
-        var y = this.gl.getUniformLocation(this.program, 'Ytex');
+        const y = this.gl.getUniformLocation(this.program, 'Ytex');
         this.gl.uniform1i(y, 0); /* Bind Ytex to texture unit 0 */
-        var u = this.gl.getUniformLocation(this.program, 'Utex');
+        const u = this.gl.getUniformLocation(this.program, 'Utex');
         this.gl.uniform1i(u, 1); /* Bind Utex to texture unit 1 */
-        var v = this.gl.getUniformLocation(this.program, 'Vtex');
+        const v = this.gl.getUniformLocation(this.program, 'Vtex');
         this.gl.uniform1i(v, 2); /* Bind Vtex to texture unit 2 */
-    };
-    WebGLRenderer.prototype.releaseTextures = function () {
-        var _a, _b, _c, _d, _e, _f;
-        (_a = this.gl) === null || _a === void 0 ? void 0 : _a.deleteProgram(this.program);
+    }
+    releaseTextures() {
+        this.gl?.deleteProgram(this.program);
         this.program = undefined;
         this.positionLocation = undefined;
         this.texCoordLocation = undefined;
-        (_b = this.gl) === null || _b === void 0 ? void 0 : _b.deleteTexture(this.yTexture);
-        (_c = this.gl) === null || _c === void 0 ? void 0 : _c.deleteTexture(this.uTexture);
-        (_d = this.gl) === null || _d === void 0 ? void 0 : _d.deleteTexture(this.vTexture);
+        this.gl?.deleteTexture(this.yTexture);
+        this.gl?.deleteTexture(this.uTexture);
+        this.gl?.deleteTexture(this.vTexture);
         this.yTexture = null;
         this.uTexture = null;
         this.vTexture = null;
-        (_e = this.gl) === null || _e === void 0 ? void 0 : _e.deleteBuffer(this.texCoordBuffer);
-        (_f = this.gl) === null || _f === void 0 ? void 0 : _f.deleteBuffer(this.surfaceBuffer);
+        this.gl?.deleteBuffer(this.texCoordBuffer);
+        this.gl?.deleteBuffer(this.surfaceBuffer);
         this.texCoordBuffer = null;
         this.surfaceBuffer = null;
-    };
-    return WebGLRenderer;
-}(IRenderer_1.IRenderer));
+    }
+}
 exports.WebGLRenderer = WebGLRenderer;