@openglobus/og 0.13.7 → 0.13.10

package/src/og/shaders/label.js

@@ -92,6 +92,7 @@ export function label_webgl2() {
 
                 if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
+                    v_fontIndex = -1;
                     return;
                 }
                
@@ -154,7 +155,6 @@ export function label_webgl2() {
             uniform int isOutlinePass;
             
             precision highp float;
-            precision highp int;
 
             const int MAX_SIZE = 11;
 
@@ -207,51 +207,33 @@ export function label_webgl2() {
                 }
                 return median(msdf.r, msdf.g, msdf.b);
             }
-
-            vec4 getSDFParams() {
-                if(v_fontIndex == 0) {
-                    return sdfParamsArr[0];
-                } else if(v_fontIndex == 1){
-                    return sdfParamsArr[1];
-                } else if(v_fontIndex == 2){
-                    return sdfParamsArr[2];
-                } else if(v_fontIndex == 3){
-                    return sdfParamsArr[3];
-                } else if(v_fontIndex == 4){
-                    return sdfParamsArr[4];
-                } else if(v_fontIndex == 5){
-                    return sdfParamsArr[5];
-                } else if(v_fontIndex == 6){
-                    return sdfParamsArr[6];
-                } else if(v_fontIndex == 7){
-                    return sdfParamsArr[7];
-                } else if(v_fontIndex == 8){
-                    return sdfParamsArr[8];
-                } else if(v_fontIndex == 9){
-                    return sdfParamsArr[9];
-                } else if(v_fontIndex == 10){
-                    return sdfParamsArr[10];
-                }
-            }
                         
             void main () {
-
-                vec4 sdfParams = getSDFParams();
+            
+                if(v_fontIndex == -1) {
+                    return;
+                }
+                
+                vec4 sdfParams = sdfParamsArr[v_fontIndex];
                 float sd = getDistance();             
                 vec2 dxdy = fwidth(v_uv) * sdfParams.xy;
-                float dist = sd + min(0.001, 0.5 - 1.0 / sdfParams.w) - 0.5;
-                float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
 
                 if(isOutlinePass == 0){                             
+                    float dist = sd + min(0.001, 0.5 - 1.0 / sdfParams.w) - 0.5;
+                    float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
+                    if(opacity <= 0.1){
+                        discard;
+                    }
                     outScreen = vec4(v_rgba.rgb, opacity * v_rgba.a);
-                } else {                
-                    float strokeDist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
-                    float strokeAlpha = v_rgba.a * clamp(strokeDist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                    
-                    if(strokeAlpha < 0.1){
+                } else {             
+                    float dist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
+                    float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                       
+                    if(opacity <= 0.1){
                         discard;
                     }
-                    outScreen = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
-                }                
+                    outScreen = vec4(v_rgba.rgb, opacity * v_rgba.a);
+                    //outScreen = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
+                }         
             }`
     });
 }
@@ -326,6 +308,7 @@ export function label_screen() {
 
                 if(a_texCoord.w == EMPTY) {
                     gl_Position = vec4(0.0);
+                    v_fontIndex = -1.0;
                     return;
                 }
                
@@ -469,6 +452,10 @@ export function label_screen() {
 
                 fontIndex = v_fontIndex + 0.1;
                 
+                if(v_fontIndex < 0.0){
+                    return;
+                }
+                
                 vec4 sdfParams = getSDFParams();
                 float sd = getDistance();             
                 vec2 dxdy = fwidth(v_uv) * sdfParams.xy;
@@ -476,14 +463,14 @@ export function label_screen() {
                 float opacity = clamp(dist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);
 
                 if(isOutlinePass == 0){                             
-                    gl_FragColor = vec4(v_rgba.rgb, opacity * v_rgba.a);
+                    //gl_FragColor = vec4(v_rgba.rgb, opacity * v_rgba.a);
                 } else {                
                     float strokeDist = sd + min(v_outline, 0.5 - 1.0 / sdfParams.w) - 0.5;
                     float strokeAlpha = v_rgba.a * clamp(strokeDist * sdfParams.w / length(dxdy) + 0.5, 0.0, 1.0);                    
                     if(strokeAlpha < 0.1){
                         discard;
                     }
-                    gl_FragColor = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
+                    //gl_FragColor = v_rgba * strokeAlpha * (0.5 - opacity) * 2.0;
                 }
             }`
     });
@@ -549,15 +536,16 @@ export function labelPicking() {
             void main() {
                 vec3 a_positions = a_positionsHigh + a_positionsLow;
                 vec3 cameraPos = eyePositionHigh + eyePositionLow;
-
+                v_rgba = a_rgba;
+                
                 if(a_texCoord.w == EMPTY) {
+                    v_rgba.a = 0.0;
                     gl_Position = vec4(0.0);
                     return;
                 }
 
                 vec3 look = a_positions - cameraPos;
                 float lookDist = length(look);
-                v_rgba = a_rgba;
                 if(opacity * step(lookDist, sqrt(dot(cameraPos,cameraPos) - planetRadius) + sqrt(dot(a_positions,a_positions) - planetRadius)) == 0.0){
                     return;
                 }
@@ -611,7 +599,7 @@ export function labelPicking() {
 
                 vec4 color = v_rgba;
                 if (color.a < 0.05) {
-                    discard;
+                    return;
                 }
 
                 gl_FragColor = vec4(v_rgba.rgb, v_rgba.a);

package/src/og/terrain/GlobusTerrain.js

@@ -10,8 +10,7 @@ import { Events } from "../Events.js";
 import { Loader } from "../utils/Loader.js";
 import { NOTRENDERING } from "../quadTree/quadTree.js";
 // import { QueueArray } from '../QueueArray.js';
-import { stringTemplate, createExtent } from "../utils/shared.js";
-import { Geoid } from "./Geoid.js";
+import { createExtent, stringTemplate } from "../utils/shared.js";
 import { Layer } from "../layer/Layer.js";
 import { Vec3 } from "../math/Vec3.js";
 import { Ray } from "../math/Ray.js";
@@ -56,7 +55,7 @@ class GlobusTerrain extends EmptyTerrain {
      */
     constructor(name, options = {}) {
         super({ geoidSrc: "//openglobus.org/geoid/egm84-30.pgm", ...options });
-
+        this._s = options.subdomains || ["a", "b", "c"];
         /**
          * Events handler.
          * @public
@@ -64,6 +63,10 @@ class GlobusTerrain extends EmptyTerrain {
          */
         this.events = new Events(EVENT_NAMES, this);
 
+        this._requestCount = 0;
+
+        this._requestsPeerSubdomian = 4;
+
         this.isEmpty = false;
 
         this.equalizeNormals = true;
@@ -73,7 +76,7 @@ class GlobusTerrain extends EmptyTerrain {
          * @public
          * @type {string}
          */
-        this.name = name || "";
+        this.name = name || "openglobus";
 
         /**
          * Minimal visible zoom index when terrain handler works.
@@ -94,7 +97,7 @@ class GlobusTerrain extends EmptyTerrain {
          * @public
          * @type {string}
          */
-        this.url = options.url || "//srtm3.openglobus.org/{z}/{y}/{x}.ddm";
+        this.url = options.url || "//{s}.srtm3.openglobus.org/{z}/{y}/{x}.ddm";
 
         /**
          * Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
@@ -192,11 +195,7 @@ class GlobusTerrain extends EmptyTerrain {
             return true;
         } else {
             if (!this._fetchCache[tileIndex]) {
-                let url = stringTemplate(this.url, {
-                    x: x,
-                    y: y,
-                    z: z
-                });
+                let url = this._buildURL(x, y, z);
                 this._fetchCache[tileIndex] = this._loader.fetch({
                     src: url,
                     type: this._dataType
@@ -279,10 +278,10 @@ class GlobusTerrain extends EmptyTerrain {
             h3 = tileData.heights[v3Ind];
 
         let v0 = new Vec3(
-            tileData.extent.southWest.lon + size * j,
-            h0,
-            tileData.extent.northEast.lat - size * i - size
-        ),
+                tileData.extent.southWest.lon + size * j,
+                h0,
+                tileData.extent.northEast.lat - size * i - size
+            ),
             v1 = new Vec3(v0.x + size, h1, v0.z),
             v2 = new Vec3(v0.x, h2, v0.z + size),
             v3 = new Vec3(v0.x + size, h3, v0.z + size);
@@ -308,7 +307,7 @@ class GlobusTerrain extends EmptyTerrain {
      * @public
      */
     abortLoading() {
-        this._loader.abort();
+        this._loader.abortAll();
     }
 
     /**
@@ -356,6 +355,7 @@ class GlobusTerrain extends EmptyTerrain {
                 } else {
                     this._loader.load(
                         {
+                            sender: this,
                             src: this._getHTTPRequestString(segment),
                             segment: segment,
                             type: this._dataType,
@@ -397,6 +397,17 @@ class GlobusTerrain extends EmptyTerrain {
         }
     }
 
+    _getSubdomain() {
+        this._requestCount++;
+        return  this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomian * this._s.length) / this._requestsPeerSubdomian)];
+    }
+
+    _buildURL(x, y, z) {
+        return stringTemplate(this.url, {
+            s: this._getSubdomain(), x, y, z
+        });
+    }
+
     /**
      * Creates query url.
      * @protected
@@ -405,11 +416,11 @@ class GlobusTerrain extends EmptyTerrain {
      * @returns {string} -
      */
     _createUrl(segment) {
-        return stringTemplate(this.url, {
-            x: segment.tileX.toString(),
-            y: segment.tileY.toString(),
-            z: segment.tileZoom.toString()
-        });
+        return this._buildURL(
+            segment.tileX.toString(),
+            segment.tileY.toString(),
+            segment.tileZoom.toString()
+        )
     }
 
     /**

package/src/og/terrain/MapboxTerrain.js

@@ -8,7 +8,7 @@ const KEY =
 
 class MapboxTerrain extends GlobusTerrain {
     constructor(name, options = {}) {
-        super(name, options);
+        super(name || "mapbox", options);
 
         this.equalizeVertices =
             options.equalizeVertices != undefined ? options.equalizeVertices : true;

package/src/og/utils/BaseWorker.js

@@ -0,0 +1,46 @@
+export class BaseWorker {
+    constructor(numWorkers = 2, program) {
+        this._id = 0;
+        this._pendingQueue = [];
+        this._numWorkers = numWorkers;
+        this._workerQueue = [];
+        if (program) this.setProgram(program);
+    }
+
+    /**
+     * @virtual
+     */
+    make() {
+    }
+
+    check() {
+        if (this._pendingQueue && this._pendingQueue.length) {
+            this.make(this._pendingQueue.pop());
+        }
+    }
+
+    setProgram(program) {
+        let elevationProgramm = new Blob([program], { type: "application/javascript" });
+
+        for (let i = 0; i < this._numWorkers; i++) {
+            let w = new Worker(URL.createObjectURL(elevationProgramm));
+            w.onmessage = (e) => {
+                this._onMessage(e);
+                this._workerQueue && this._workerQueue.unshift(e.target);
+                this.check();
+            }
+            this._workerQueue.push(w);
+        }
+    }
+
+    destroy() {
+        for (let i = 0; i < this._workerQueue.length; i++) {
+            const w = this._workerQueue[i];
+            w.onmessage = undefined;
+            w.terminate();
+        }
+        this._pendingQueue = undefined;
+        this._numWorkers = undefined;
+        this._workerQueue = undefined;
+    }
+}

package/src/og/utils/FontAtlas.js

@@ -7,7 +7,6 @@
 import { Rectangle } from '../Rectangle.js';
 import { TextureAtlas, TextureAtlasNode } from './TextureAtlas.js';
 import { Deferred } from '../Deferred.js';
-import { ARIAL_FONT_B64 } from '../res/images.js';
 
 //TODO: get the value from shader module
 const MAX_SIZE = 11;
@@ -160,7 +159,7 @@ class FontAtlas {
             this._createTexture(atlas, img);
             def.resolve(index);
         };
-        img.src = ARIAL_FONT_B64;
+        img.src = imageBase64;
     }
 
     _createTexture(atlas, img) {

package/src/og/utils/GeoImageCreator.js

@@ -1,163 +1,166 @@
-'use strict';
-
-import { LonLat } from '../LonLat.js';
-import * as utils from '../utils/shared.js';
-import { Framebuffer } from '../webgl/Framebuffer.js';
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-export class GeoImageCreator {
-
-    constructor(planet, maxFrames) {
-        this._gridSize = 64;
-        this._planet = planet;
-        this._framebuffer = null;
-        this._texCoordsBuffer = null;
-        this._indexBuffer = null;
-        this.MAX_FRAMES = maxFrames || 5;
-        this._currentFrame = 0;
-        this._queue = [];
-        this._animate = [];
-        this._initialize();
-    }
-
-    _initialize() {
-        this._initShaders();
-        this._initBuffers();
-    }
-
-    /**
-     * Creates geoImage corners coordinates grid buffer.
-     * @public
-     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
-     * @return{WebGLBuffer} Grid coordinates buffer.
-     */
-    createGridBuffer(c, toMerc) {
-        var gs = this._gridSize;
-
-        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
-            v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
-            v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
-            v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
-
-        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
-        var k = 0;
-        for (let i = 0; i <= gs; i++) {
-            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
-                P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
-            for (let j = 0; j <= gs; j++) {
-                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
-                    P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
-                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
-                grid[k++] = xx.lon;
-                grid[k++] = xx.lat;
-            }
-        }
-
-        if (toMerc) {
-            for (let i = 0; i < grid.length; i += 2) {
-                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
-                grid[i] = c.lon;
-                grid[i + 1] = c.lat;
-            }
-        }
-        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
-    }
-
-    frame() {
-        var i = this.MAX_FRAMES;
-        while (i-- && this._queue.length) {
-            var q = this._queue.shift();
-            q._isRendering = false;
-            q.rendering();
-        }
-
-        i = this._animate.length;
-        while (i--) {
-            this._animate[i].rendering();
-        }
-    }
-
-    add(geoImage) {
-        if (!geoImage._isRendering) {
-            geoImage._isRendering = true;
-            if (geoImage._animate) {
-                this._animate.push(geoImage);
-            } else {
-                this._queue.push(geoImage);
-            }
-        }
-    }
-
-    remove(geoImage) {
-        if (geoImage._isRendering) {
-            geoImage._creationProceeding = false;
-            geoImage._isRendering = false;
-            var arr;
-            if (geoImage._animate) {
-                arr = this._animate;
-            } else {
-                arr = this._queue;
-            }
-            for (var i = 0; i < arr.length; i++) {
-                if (arr[i].isEqual(geoImage)) {
-                    arr.splice(i, 1);
-                    return;
-                }
-            }
-        }
-    }
-
-    _initBuffers() {
-
-        let h = this._planet.renderer.handler;
-
-        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebuffer.init();
-
-        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebufferMercProj.init();
-
-        let gs = Math.log2(this._gridSize);
-
-        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
-
-        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
-
-        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
-        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
-    }
-
-    _initShaders() {
-
-        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
-            uniforms: {
-                sourceTexture: { type: types.SAMPLER2D },
-                extentParams: { type: types.VEC4 }
-            },
-            attributes: {
-                corners: "vec2",
-                texCoords: "vec2"
-            },
-            vertexShader: `attribute vec2 corners; 
-                      attribute vec2 texCoords; 
-                      varying vec2 v_texCoords; 
-                      uniform vec4 extentParams; 
-                      void main() { 
-                          v_texCoords = texCoords; 
-                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
-                      }`,
-            fragmentShader:
-                `precision highp float;
-                        uniform sampler2D sourceTexture;
-                        varying vec2 v_texCoords;
+'use strict';
+
+import { LonLat } from '../LonLat.js';
+import * as utils from '../utils/shared.js';
+import { Framebuffer } from '../webgl/Framebuffer.js';
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+export class GeoImageCreator {
+
+    constructor(planet, maxFrames) {
+        this._gridSize = 64;
+        this._planet = planet;
+        this._framebuffer = null;
+        this._texCoordsBuffer = null;
+        this._indexBuffer = null;
+        this.MAX_FRAMES = maxFrames || 5;
+        this._currentFrame = 0;
+        this._queue = [];
+        this._animate = [];
+        this._initialize();
+    }
+
+    _initialize() {
+        this._initShaders();
+        this._initBuffers();
+    }
+
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    createGridBuffer(c, toMerc) {
+        var gs = this._gridSize;
+
+        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
+            v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
+            v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
+            v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
+
+        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
+        var k = 0;
+        for (let i = 0; i <= gs; i++) {
+            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
+                P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
+            for (let j = 0; j <= gs; j++) {
+                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
+                    P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
+                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
+                grid[k++] = xx.lon;
+                grid[k++] = xx.lat;
+            }
+        }
+
+        if (toMerc) {
+            for (let i = 0; i < grid.length; i += 2) {
+                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
+                grid[i] = c.lon;
+                grid[i + 1] = c.lat;
+            }
+        }
+        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
+    }
+
+    frame() {
+        var i = this.MAX_FRAMES;
+        while (i-- && this._queue.length) {
+            var q = this._queue.shift();
+            q._isRendering = false;
+            q.rendering();
+            q.events.dispatch(q.events.loadend);
+        }
+
+        i = this._animate.length;
+        while (i--) {
+            this._animate[i].rendering();
+        }
+    }
+
+    add(geoImage) {
+        if (!geoImage._isRendering) {
+            geoImage._isRendering = true;
+            if (geoImage._animate) {
+                this._animate.push(geoImage);
+            } else {
+                this._queue.push(geoImage);
+            }
+        }
+    }
+
+    remove(geoImage) {
+        if (geoImage._isRendering) {
+            geoImage._creationProceeding = false;
+            geoImage._isRendering = false;
+            var arr;
+            if (geoImage._animate) {
+                arr = this._animate;
+            } else {
+                arr = this._queue;
+            }
+            for (var i = 0; i < arr.length; i++) {
+                if (arr[i].isEqual(geoImage)) {
+                    arr.splice(i, 1);
+                    return;
+                }
+            }
+        }
+    }
+
+    _initBuffers() {
+
+        let h = this._planet.renderer.handler;
+
+        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebuffer.init();
+
+        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebufferMercProj.init();
+
+        let gs = Math.log2(this._gridSize);
+
+        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
+
+        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
+
+        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
+        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
+    }
+
+    _initShaders() {
+
+        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
+            uniforms: {
+                sourceTexture: "sampler2d",
+                extentParams: "vec4",
+                isFullExtent: "bool"
+            },
+            attributes: {
+                corners: "vec2",
+                texCoords: "vec2"
+            },
+            vertexShader: `attribute vec2 corners; 
+                      attribute vec2 texCoords; 
+                      varying vec2 v_texCoords; 
+                      uniform vec4 extentParams; 
+                      void main() { 
+                          v_texCoords = texCoords; 
+                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
+                      }`,
+            fragmentShader:
+                `precision highp float;
+                        uniform sampler2D sourceTexture;
+                        uniform bool isFullExtent;
+                        varying vec2 v_texCoords;
                         void main () {
-                            if(v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
-                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999) {
-                                discard;
-                            }
-                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
-                        }`
-        }));
-    }
+                            if(!isFullExtent && (v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
+                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999)) {
+                                discard;
+                            }
+                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
+                        }`
+        }));
+    }
 }