+var gMap = {
+ gl: null,
+ glShaderProgram: null,
+ glVertexPositionAttr: null,
+ glTextureCoordAttr: null,
+ glResolutionAttr: null,
+ glMapTexture: null,
+ glTextures: {},
+ glTextureKeys: {},
+
+ activeMap: "osm_mapnik",
+ tileSize: 256,
+ maxZoom: 18, // The minimum is 0.
+ zoomFactor: null,
+ pos: {
+ x: 35630000.0, // Current position in the map in pixels at the maximum zoom level (18)
+ y: 23670000.0, // The range is 0-67108864 (2^gMap.maxZoom * gMap.tileSize)
+ z: 5 // This could be fractional if supported being between zoom levels.
+ },
+
+ get width() { return gMap.gl ? gMap.gl.drawingBufferWidth : gGLMapCanvas.width; },
+ get height() { return gMap.gl ? gMap.gl.drawingBufferHeight : gGLMapCanvas.height; },
+
+ getVertShaderSource: function() {
+ return 'attribute vec2 aVertexPosition;\n' +
+ 'attribute vec2 aTextureCoord;\n\n' +
+ 'uniform vec2 uResolution;\n\n' +
+ 'varying highp vec2 vTextureCoord;\n\n' +
+ 'void main(void) {\n' +
+ // convert the rectangle from pixels to -1.0 to +1.0 (clipspace) 0.0 to 1.0
+ ' vec2 clipSpace = aVertexPosition * 2.0 / uResolution - 1.0;\n' +
+ ' gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);\n' +
+ ' vTextureCoord = aTextureCoord;\n' +
+ '}'; },
+ getFragShaderSource:function() {
+ return 'varying highp vec2 vTextureCoord;\n\n' +
+ 'uniform sampler2D uImage;\n\n' +
+ 'void main(void) {\n' +
+ ' gl_FragColor = texture2D(uImage, vTextureCoord);\n' +
+ '}'; },
+
+ initGL: function() {
+ // When called from the event listener, the "this" reference doesn't work, so use the object name.
+ if (gMap.gl) {
+ gMap.gl.viewport(0, 0, gMap.gl.drawingBufferWidth, gMap.gl.drawingBufferHeight);
+ gMap.gl.clearColor(0.0, 0.0, 0.0, 0.5); // Set clear color to black, fully opaque.
+ gMap.gl.clear(gMap.gl.COLOR_BUFFER_BIT|gMap.gl.DEPTH_BUFFER_BIT); // Clear the color.
+
+ // Create and initialize the shaders.
+ var vertShader = gMap.gl.createShader(gMap.gl.VERTEX_SHADER);
+ var fragShader = gMap.gl.createShader(gMap.gl.FRAGMENT_SHADER);
+ gMap.gl.shaderSource(vertShader, gMap.getVertShaderSource());
+ // Compile the shader program.
+ gMap.gl.compileShader(vertShader);
+ // See if it compiled successfully.
+ if (!gMap.gl.getShaderParameter(vertShader, gMap.gl.COMPILE_STATUS)) {
+ console.log("An error occurred compiling the vertex shader: " + gMap.gl.getShaderInfoLog(vertShader));
+ return null;
+ }
+ gMap.gl.shaderSource(fragShader, gMap.getFragShaderSource());
+ // Compile the shader program.
+ gMap.gl.compileShader(fragShader);
+ // See if it compiled successfully.
+ if (!gMap.gl.getShaderParameter(fragShader, gMap.gl.COMPILE_STATUS)) {
+ console.log("An error occurred compiling the fragment shader: " + gMap.gl.getShaderInfoLog(fragShader));
+ return null;
+ }
+
+ gMap.glShaderProgram = gMap.gl.createProgram();
+ gMap.gl.attachShader(gMap.glShaderProgram, vertShader);
+ gMap.gl.attachShader(gMap.glShaderProgram, fragShader);
+ gMap.gl.linkProgram(gMap.glShaderProgram);
+ // If creating the shader program failed, alert
+ if (!gMap.gl.getProgramParameter(gMap.glShaderProgram, gMap.gl.LINK_STATUS)) {
+ alert("Unable to initialize the shader program.");
+ }
+ gMap.gl.useProgram(gMap.glShaderProgram);
+ // Get locations of the attributes.
+ gMap.glVertexPositionAttr = gMap.gl.getAttribLocation(gMap.glShaderProgram, "aVertexPosition");
+ gMap.glTextureCoordAttr = gMap.gl.getAttribLocation(gMap.glShaderProgram, "aTextureCoord");
+ gMap.glResolutionAttr = gMap.gl.getUniformLocation(gMap.glShaderProgram, "uResolution");
+
+ var tileVerticesBuffer = gMap.gl.createBuffer();
+ gMap.gl.bindBuffer(gMap.gl.ARRAY_BUFFER, tileVerticesBuffer);
+ // The vertices are the coordinates of the corner points of the square.
+ var vertices = [
+ 0.0, 0.0,
+ 1.0, 0.0,
+ 0.0, 1.0,
+ 0.0, 1.0,
+ 1.0, 0.0,
+ 1.0, 1.0,
+ ];
+ gMap.gl.bufferData(gMap.gl.ARRAY_BUFFER, new Float32Array(vertices), gMap.gl.STATIC_DRAW);
+ gMap.gl.enableVertexAttribArray(gMap.glTextureCoordAttr);
+ gMap.gl.vertexAttribPointer(gMap.glTextureCoordAttr, 2, gMap.gl.FLOAT, false, 0, 0);
+
+ gMap.loadImageToTexture(gLoadingTile, 0, "loading::0,0,0");
+
+ gMap.gl.uniform2f(gMap.glResolutionAttr, gGLMapCanvas.width, gGLMapCanvas.height);
+
+ // Create a buffer for the position of the rectangle corners.
+ var mapVerticesTextureCoordBuffer = gMap.gl.createBuffer();
+ gMap.gl.bindBuffer(gMap.gl.ARRAY_BUFFER, mapVerticesTextureCoordBuffer);
+ gMap.gl.enableVertexAttribArray(gMap.glVertexPositionAttr);
+ gMap.gl.vertexAttribPointer(gMap.glVertexPositionAttr, 2, gMap.gl.FLOAT, false, 0, 0);
+ }
+
+ var throwEv = new CustomEvent("mapinit-done");
+ gAction.dispatchEvent(throwEv);
+ },
+
+ draw: function(aPixels, aOverdraw) {
+ gMap.assembleGL(aPixels);
+ drawTrack();
+ },
+
+ assembleGL: function(aPixels) {
+ if (!gMap.gl) { return; }
+ // aPixels is an object with left/right/top/bottom members telling how many
+ // pixels on the borders should actually be drawn.
+ if (!aPixels)
+ aPixels = {left: gMap.gl.drawingBufferWidth, right: gMap.gl.drawingBufferWidth,
+ top: gMap.gl.drawingBufferHeight, bottom: gMap.gl.drawingBufferHeight};
+
+ document.getElementById("zoomLevel").textContent = gMap.pos.z;
+ gMap.zoomFactor = Math.pow(2, gMap.maxZoom - gMap.pos.z);
+ var wid = gMap.gl.drawingBufferWidth * gMap.zoomFactor; // Width in level 18 pixels.
+ var ht = gMap.gl.drawingBufferHeight * gMap.zoomFactor; // Height in level 18 pixels.
+ var size = gMap.tileSize * gMap.zoomFactor; // Tile size in level 18 pixels.
+
+ var xMin = gMap.pos.x - wid / 2; // Corners of the window in level 18 pixels.
+ var yMin = gMap.pos.y - ht / 2;
+ var xMax = gMap.pos.x + wid / 2;
+ var yMax = gMap.pos.y + ht / 2;
+
+ if (gMapPrefsLoaded && mainDB)
+ gPrefs.set("position", gMap.pos);
+
+ var tiles = {left: Math.ceil((xMin + aPixels.left * gMap.zoomFactor) / size) -
+ (aPixels.left ? 0 : 1),
+ right: Math.floor((xMax - aPixels.right * gMap.zoomFactor) / size) -
+ (aPixels.right ? 1 : 0),
+ top: Math.ceil((yMin + aPixels.top * gMap.zoomFactor) / size) -
+ (aPixels.top ? 0 : 1),
+ bottom: Math.floor((yMax - aPixels.bottom * gMap.zoomFactor) / size) -
+ (aPixels.bottom ? 1 : 0)};
+
+ // Go through all the tiles in the map, find out if to draw them and do so.
+ for (var x = Math.floor(xMin / size); x < Math.ceil(xMax / size); x++) {
+ for (var y = Math.floor(yMin / size); y < Math.ceil(yMax / size); y++) { // slow script warnings on the tablet appear here!
+ // Only go to loading step if we need to fetch the image for this tile.
+ if (x < tiles.left || x > tiles.right ||
+ y < tiles.top || y > tiles.bottom) {
+ // Initiate loading/drawing of the actual tile.
+ gTileService.get(gMap.activeMap, {x: x, y: y, z: gMap.pos.z},
+ function(aImage, aStyle, aCoords, aTileKey) {
+ // Only load if this applies for the current view.
+ if ((aStyle == gMap.activeMap) && (aCoords.z == gMap.pos.z)) {
+ var txIndex = gMap.glTextureKeys[aTileKey];
+ if (!txIndex) {
+ var URL = window.URL;
+ var imgURL = URL.createObjectURL(aImage);
+ var imgObj = new Image();
+ imgObj.onload = function() {
+ var txNr = 1;
+ while (gMap.glTextures["tx" + txNr]) { txNr++; }
+ gMap.loadImageToTexture(imgObj, txNr, aTileKey);
+ requestAnimationFrame(function(aTimestamp) { gMap.drawGL() });
+ URL.revokeObjectURL(imgURL);
+ }
+ imgObj.src = imgURL;
+ }
+ }
+ });
+ }
+ }
+ }
+ requestAnimationFrame(function(aTimestamp) { gMap.drawGL() });
+ },
+
+ drawGL: function() {
+ var wid = gMap.gl.drawingBufferWidth * gMap.zoomFactor; // Width in level 18 pixels.
+ var ht = gMap.gl.drawingBufferHeight * gMap.zoomFactor; // Height in level 18 pixels.
+ var size = gMap.tileSize * gMap.zoomFactor; // Tile size in level 18 pixels.
+
+ var xMin = gMap.pos.x - wid / 2; // Corners of the window in level 18 pixels.
+ var yMin = gMap.pos.y - ht / 2;
+ var xMax = gMap.pos.x + wid / 2;
+ var yMax = gMap.pos.y + ht / 2;
+
+ var txIndexList = [];
+ // Go through all the tiles in the map, find out if to draw them and do so.
+ for (var x = Math.floor(xMin / size); x < Math.ceil(xMax / size); x++) {
+ for (var y = Math.floor(yMin / size); y < Math.ceil(yMax / size); y++) { // slow script warnings on the tablet appear here!
+ // Round here is **CRUCIAL** otherwise the images are filtered
+ // and the performance sucks (more than expected).
+ var xoff = Math.round((x * size - xMin) / gMap.zoomFactor);
+ var yoff = Math.round((y * size - yMin) / gMap.zoomFactor);
+ // Draw the tile, first find out the index of the texture to use.
+ var norm = normalizeCoords({x: x, y: y, z: gMap.pos.z});
+ var tileKey = getTileKey(gMap.activeMap, norm);
+ var txIndex = gMap.glTextureKeys[tileKey];
+ if (!txIndex) { txIndex = 0; }
+ txIndexList.push(txIndex);
+ gMap.drawTileGL(xoff, yoff, txIndex);
+ }
+ }
+ console.log("Used Indexes: " + txIndexList.join(","));
+ },
+
+ resizeAndDraw: function() {
+ var viewportWidth = Math.min(window.innerWidth, window.outerWidth);
+ var viewportHeight = Math.min(window.innerHeight, window.outerHeight);
+ if (gGLMapCanvas && gTrackCanvas) {
+ gGLMapCanvas.width = viewportWidth;
+ gGLMapCanvas.height = viewportHeight;
+ gTrackCanvas.width = viewportWidth;
+ gTrackCanvas.height = viewportHeight;
+ if (gMap.gl) {
+ // Size viewport to canvas size.
+ gMap.gl.viewport(0, 0, gMap.gl.drawingBufferWidth, gMap.gl.drawingBufferHeight);
+ // Clear the color.
+ gMap.gl.clear(gMap.gl.COLOR_BUFFER_BIT);
+ // Make sure the vertex shader get the right resolution.
+ gMap.gl.uniform2f(gMap.glResolutionAttr, gGLMapCanvas.width, gGLMapCanvas.height);
+ }
+ gMap.draw();
+ showUI();
+ }
+ },
+
+ drawTileGL: function(aLeft, aRight, aTextureIndex) {
+ gMap.gl.activeTexture(gMap.gl.TEXTURE0);
+ gMap.gl.bindTexture(gMap.gl.TEXTURE_2D, gMap.glTextures["tx" + aTextureIndex]);
+ // Set uImage to refer to TEXTURE0
+ gMap.gl.uniform1i(gMap.gl.getUniformLocation(gMap.glShaderProgram, "uImage"), 0);
+ var x_start = aLeft;
+ var i_width = gMap.tileSize;
+ var y_start = aRight;
+ var i_height = gMap.tileSize;
+ var textureCoordinates = [
+ x_start, y_start,
+ x_start + i_width, y_start,
+ x_start, y_start + i_height,
+ x_start, y_start + i_height,
+ x_start + i_width, y_start,
+ x_start + i_width, y_start + i_height,
+ ];
+ gMap.gl.bufferData(gMap.gl.ARRAY_BUFFER, new Float32Array(textureCoordinates), gMap.gl.STATIC_DRAW);
+
+ // There are 6 indices in textureCoordinates.
+ gMap.gl.drawArrays(gMap.gl.TRIANGLES, 0, 6);
+ },
+
+ loadImageToTexture: function(aImage, aTextureIndex, aTileKey) {
+ // TODO: Get rid of old textures.
+ gMap.glTextureKeys[aTileKey] = aTextureIndex;
+ // Create and bind texture.
+ gMap.glTextures["tx" + aTextureIndex] = gMap.gl.createTexture();
+ gMap.gl.bindTexture(gMap.gl.TEXTURE_2D, gMap.glTextures["tx" + aTextureIndex]);
+ // Set params for how the texture minifies and magnifies (wrap params are not needed as we're power-of-two).
+ gMap.gl.texParameteri(gMap.gl.TEXTURE_2D, gMap.gl.TEXTURE_MIN_FILTER, gMap.gl.NEAREST);
+ gMap.gl.texParameteri(gMap.gl.TEXTURE_2D, gMap.gl.TEXTURE_MAG_FILTER, gMap.gl.NEAREST);
+ // Upload the image into the texture.
+ gMap.gl.texImage2D(gMap.gl.TEXTURE_2D, 0, gMap.gl.RGBA, gMap.gl.RGBA, gMap.gl.UNSIGNED_BYTE, aImage);
+ },
projects / lantea.git / blobdiff