diff --git a/core/texture.js b/core/texture.js
index 5f1100d34..b42ec8553 100644
--- a/core/texture.js
+++ b/core/texture.js
@@ -104,6 +104,8 @@ X.texture = function() {
    * @protected
    */
   this._grayscale = false;
+
+  this._needs_update = false;
   
   // inject functionality
   inject(this, new X.loadable()); // this object is loadable from a file
@@ -113,6 +115,19 @@ X.texture = function() {
 goog.inherits(X.texture, X.base);
 
 
+/**
+ * Get the raw data of this texture.
+ * 
+ * @return {?Object} The raw data array (Uint8Array).
+ */
+X.texture.prototype.__defineGetter__('rawData', function() {
+
+  return this._rawData;
+  
+});
+
+
+
 /**
  * Set the raw data of this texture.
  * 
@@ -168,4 +183,14 @@ X.texture.prototype.__defineSetter__('grayscale', function(grayscale) {
   
 });
 
+X.texture.prototype.updateTexture = function(data) {
+
+  this._rawData = data;
+  this._needs_update = true;
+
+  this._dirty = true;
+
+};
+
 goog.exportSymbol('X.texture', X.texture);
+goog.exportSymbol('X.texture.prototype.updateTexture', X.texture.prototype.updateTexture);
diff --git a/io/interactor.js b/io/interactor.js
index 96c110a40..d0318092b 100644
--- a/io/interactor.js
+++ b/io/interactor.js
@@ -363,17 +363,17 @@ X.interactor.prototype.init = function() {
     this._element.oncontextmenu = null;
   }
 
-  if (this._config['KEYBOARD_ENABLED']) {
+  // if (this._config['KEYBOARD_ENABLED']) {
 
-    // the google closure way did not work, so let's do it this way..
-    window.onkeydown = this.onKey_.bind(this);
+  //   // the google closure way did not work, so let's do it this way..
+  //   window.onkeydown = this.onKey_.bind(this);
 
-  } else {
+  // } else {
 
-    // remove the keyboard observer
-    window.onkeydown = null;
+  //   // remove the keyboard observer
+  //   window.onkeydown = null;
 
-  }
+  // }
 
   // touch events
   if (this._config['TOUCH_ENABLED']) {
@@ -561,13 +561,13 @@ X.interactor.prototype.onMouseMovementOutside_ = function(event) {
 
   // reset the click flags
   this._mouseInside = false;
-  if (this._config['KEYBOARD_ENABLED']) {
+  // if (this._config['KEYBOARD_ENABLED']) {
 
-    // if we observe the keyboard, remove the observer here
-    // this is necessary if there are more than one renderer in the document
-    window.onkeydown = null;
+  //   // if we observe the keyboard, remove the observer here
+  //   // this is necessary if there are more than one renderer in the document
+  //   window.onkeydown = null;
 
-  }
+  // }
 
   this._leftButtonDown = false;
   this._middleButtonDown = false;
@@ -940,13 +940,13 @@ X.interactor.prototype.onMouseMovementInside_ = function(event) {
 
   this._mouseInside = true;
 
-  if (this._config['KEYBOARD_ENABLED'] && window.onkeydown == null) {
+  // if (this._config['KEYBOARD_ENABLED'] && window.onkeydown == null) {
 
-    // we re-gained the focus, enable the keyboard observer again!
-    window.onkeydown = this.onKey_.bind(this);
+  //   // we re-gained the focus, enable the keyboard observer again!
+  //   window.onkeydown = this.onKey_.bind(this);
 
 
-  }
+  // }
 
   // prevent any other actions by the browser (f.e. scrolling, selection..)
   event.preventDefault();
diff --git a/io/parser.js b/io/parser.js
index 3dbce8e22..d7174311a 100644
--- a/io/parser.js
+++ b/io/parser.js
@@ -830,11 +830,11 @@ X.parser.reslice2 = function(_sliceOrigin, _sliceXYSpacing, _sliceNormal, _color
   var _resX = _sliceXYSpacing[0];
   var _resY = _sliceXYSpacing[1];
 
-  var _epsilon = 0.0000001;
+  var _epsilon = 0.000;//0001;
 
   // How many pixels are we expecting the raw data
-  var _cswidth = Math.ceil(_swidth/_resX);
-  var _csheight = Math.ceil(_sheight/_resY);
+  var _cswidth = Math.ceil(_swidth/_resX)+1;
+  var _csheight = Math.ceil(_sheight/_resY)+1;
 
   var _csize =  _cswidth*_csheight;
   var textureSize = 4 * _csize;
@@ -910,8 +910,15 @@ X.parser.reslice2 = function(_sliceOrigin, _sliceXYSpacing, _sliceNormal, _color
           pixelValue_b = 255 * lookupValue[3];
           pixelValue_a = 255 * lookupValue[4];
       
-        }
-        else {
+        } else if(object._32bit) {
+
+          // 32 bit textures
+          pixelValue_r = pixval[0];
+          pixelValue_g = pixval[1];
+          pixelValue_b = pixval[2];
+          pixelValue_a = pixval[3];
+
+        } else {
       
           pixelValue_r = pixelValue_g = pixelValue_b = 255 * (pixval / object._max);
           pixelValue_a = 255;
@@ -1118,7 +1125,7 @@ X.parser.prototype.updateSliceInfo = function(_index, _sliceOrigin, _sliceNormal
  *          object The X.volume to fill.
  * @return {!Array} The volume data as a 3D Array.
  */
-X.parser.prototype.reslice = function(object) {
+X.parser.prototype.reslice_old = function(object) {
   
   // ------------------------------------------
   // CREATE IJK VOLUMES
@@ -1126,13 +1133,16 @@ X.parser.prototype.reslice = function(object) {
   
   // Step 1: create 2 IJK volumes
   // 1 full res, 1 normalized [0-255]
-  
-  var _IJKVolumes = X.parser.createIJKVolume(object._data, object._dimensions, object._max);
+  // if (object._32bit) {
+  //   var _IJKVolumes = X.parser.createIJKVolume32(object._data, object._dimensions, object._max);  
+  // } else {
+  //   var _IJKVolumes = X.parser.createIJKVolume(object._data, object._dimensions, object._max);
+
   // real volume
-  object._IJKVolume = _IJKVolumes[0];
-  // normalized volume
-  object._IJKVolumeN = _IJKVolumes[1];
-  X.TIMER(this._classname + '.reslice');
+  // object._IJKVolume = _IJKVolumes[0];
+  // // normalized volume
+  // object._IJKVolumeN = _IJKVolumes[1];
+  X.TIMER(this._classname + '.reslice_old');
   
   // ------------------------------------------
   // SETUP LABEL MAPS AND COLOR TABLES
@@ -1196,16 +1206,16 @@ X.parser.prototype.reslice = function(object) {
   _sliceOrigin[1] = object._childrenInfo[0]._solutionsLine[0][0][1] + object._childrenInfo[0]._sliceDirection[1]*Math.floor(object._childrenInfo[0]._nb/2);
   _sliceOrigin[2] = object._childrenInfo[0]._solutionsLine[0][0][2] + object._childrenInfo[0]._sliceDirection[2]*Math.floor(object._childrenInfo[0]._nb/2);
 
-  var _slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[0]._sliceXYSpacing, object._childrenInfo[0]._sliceNormal, object._childrenInfo[0]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
+  //var _slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[0]._sliceXYSpacing, object._childrenInfo[0]._sliceNormal, object._childrenInfo[0]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
     
   if (object.hasLabelMap) {
     // if this object has a labelmap,
     // we have it loaded at this point (for sure)
     // ..so we can attach it as the second texture to this slice
-    _slice._labelmap = object._labelmap._children[0]._children[Math.floor(object._childrenInfo[0]._nb/2)]._texture;
+    //_slice._labelmap = object._labelmap._children[0]._children[Math.floor(object._childrenInfo[0]._nb/2)]._texture;
   }
     
-  object._children[0]._children[Math.floor(object._childrenInfo[0]._nb/2)] = _slice;
+  //object._children[0]._children[Math.floor(object._childrenInfo[0]._nb/2)] = _slice;
 
   object._indexX = Math.floor(object._childrenInfo[0]._nb/2);
   object._indexXold = Math.floor(object._childrenInfo[0]._nb/2);
@@ -1243,16 +1253,16 @@ X.parser.prototype.reslice = function(object) {
   _sliceOrigin[1] = object._childrenInfo[1]._solutionsLine[0][0][1] + object._childrenInfo[1]._sliceDirection[1]*Math.floor(object._childrenInfo[1]._nb/2);
   _sliceOrigin[2] = object._childrenInfo[1]._solutionsLine[0][0][2] + object._childrenInfo[1]._sliceDirection[2]*Math.floor(object._childrenInfo[1]._nb/2);
 
-  _slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[1]._sliceXYSpacing, object._childrenInfo[1]._sliceNormal, object._childrenInfo[1]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
+  //_slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[1]._sliceXYSpacing, object._childrenInfo[1]._sliceNormal, object._childrenInfo[1]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
     
   if (object.hasLabelMap) {
     // if this object has a labelmap,
     // we have it loaded at this point (for sure)
     // ..so we can attach it as the second texture to this slice
-    _slice._labelmap = object._labelmap._children[1]._children[Math.floor(object._childrenInfo[1]._nb/2)]._texture;
+    //_slice._labelmap = object._labelmap._children[1]._children[Math.floor(object._childrenInfo[1]._nb/2)]._texture;
   }
     
-  object._children[1]._children[Math.floor(object._childrenInfo[1]._nb/2)] = _slice;
+  //object._children[1]._children[Math.floor(object._childrenInfo[1]._nb/2)] = _slice;
   
   object._indexY = Math.floor(object._childrenInfo[1]._nb/2);
   object._indexYold = Math.floor(object._childrenInfo[1]._nb/2);
@@ -1289,22 +1299,207 @@ X.parser.prototype.reslice = function(object) {
   _sliceOrigin[1] = object._childrenInfo[2]._solutionsLine[0][0][1] + object._childrenInfo[2]._sliceDirection[1]*Math.floor(object._childrenInfo[2]._nb/2);
   _sliceOrigin[2] = object._childrenInfo[2]._solutionsLine[0][0][2] + object._childrenInfo[2]._sliceDirection[2]*Math.floor(object._childrenInfo[2]._nb/2);
     
-  _slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[2]._sliceXYSpacing, object._childrenInfo[2]._sliceNormal, object._childrenInfo[2]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
+  //_slice = X.parser.reslice2(_sliceOrigin, object._childrenInfo[2]._sliceXYSpacing, object._childrenInfo[2]._sliceNormal, object._childrenInfo[2]._color, object._BBox, object._IJKVolume, object, object.hasLabelMap, object._colorTable);
     
   if (object.hasLabelMap) {
     // if this object has a labelmap,
     // we have it loaded at this point (for sure)
     // ..so we can attach it as the second texture to this slice
-    _slice._labelmap = object._labelmap._children[2]._children[Math.floor(object._childrenInfo[2]._nb/2)]._texture;
+    //_slice._labelmap = object._labelmap._children[2]._children[Math.floor(object._childrenInfo[2]._nb/2)]._texture;
   }
     
-  object._children[2]._children[Math.floor(object._childrenInfo[2]._nb/2)] = _slice;
+  //object._children[2]._children[Math.floor(object._childrenInfo[2]._nb/2)] = _slice;
   
   object._indexZ = Math.floor(object._childrenInfo[2]._nb/2);
   object._indexZold = Math.floor(object._childrenInfo[2]._nb/2);
 
-  X.TIMERSTOP(this._classname + '.reslice');
+
+  if (object._indexZ % 2 != 0) {
+    object._indexZ -= 1;
+    object._indexZold -= 1;
+  }
+
+  X.TIMERSTOP(this._classname + '.reslice_old');
   
-  return object._IJKVolume;
+  //return object._IJKVolume;
 };
 
+X.parser.prototype.reslice = function(object) {
+
+  X.TIMER(this._classname + '.reslice');
+
+  var data = object._data;
+
+  var bytes_per_value = object._32bit ? 4 : 1;
+
+  var grayscale = (bytes_per_value == 1);
+
+  var dim_x = object._dimensions[0];
+  var dim_y = object._dimensions[1];
+  var dim_z = object._dimensions[2];
+
+  var texture_dim_x = dim_x;
+  var texture_dim_y = dim_y;
+  var texture_dim_z = dim_z;
+
+  var x_y_sample_rate = object._x_y_sample_rate;
+  var z_sample_rate = object._z_sample_rate;
+
+  // if (!grayscale) {
+  //   var texture_dim_x = Math.pow(2,Math.ceil(Math.log(dim_x)/Math.log(2)));
+  //   var texture_dim_y = Math.pow(2,Math.ceil(Math.log(dim_y)/Math.log(2)));
+  //   var texture_dim_z = Math.pow(2,Math.ceil(Math.log(dim_z)/Math.log(2)));
+  // }
+
+  var spacing_x = object._spacing[0];
+  var spacing_y = object._spacing[1];
+  var spacing_z = object._spacing[2];
+
+  var data_length = dim_x * dim_y * dim_z * bytes_per_value;  
+
+  var nb_pix_per_z = dim_x * dim_y;
+
+  var slices_x = new Array(dim_x);
+  var slices_y = new Array(dim_y);
+  var slices_z = new Array(dim_z);
+
+  var labelmap = object._labelmap;
+
+  // allocate slices x y z
+  for (var x=0; x<dim_x; ++x) {
+    slices_x[x] = new Uint8Array(texture_dim_y*texture_dim_z*bytes_per_value);
+  }
+  for (var y=0; y<dim_y; ++y) {
+    slices_y[y] = new Uint8Array(texture_dim_x*texture_dim_z*bytes_per_value);
+  }
+  for (var z=0; z<dim_z; ++z) {
+    slices_z[z] = new Uint8Array(texture_dim_x*texture_dim_y*bytes_per_value);
+  }
+
+  // loop through data to create the slices
+  var px = 0;
+  for (var p=0; p<data_length; p+=bytes_per_value) {
+
+    var z = Math.floor(px / nb_pix_per_z);
+    var y = Math.floor((px % nb_pix_per_z) / dim_x);
+    var x = Math.floor((px % nb_pix_per_z) % dim_x);
+
+    var z_index = (x + y*dim_y)*bytes_per_value;
+    var y_index = (x + z*dim_x)*bytes_per_value;
+    var x_index = (y + z*dim_y)*bytes_per_value;
+
+    for (var i=0;i<bytes_per_value;i++) {
+
+      slices_x[x][x_index+i] = data[p+i];
+      slices_y[y][y_index+i] = data[p+i];
+      slices_z[z][z_index+i] = data[p+i];
+
+    }
+
+    px++;
+
+  }
+
+// parserRAW.parse: 946.685ms X.js:95
+// parserRAW.reslice_old: 4.265ms X.js:95
+// 19660800 19660800 parser.js:1428
+// parserRAW.reslice: 827.655ms X.js:95
+// 19660800*4
+// 78643200
+
+
+  // create the slices
+  for (var x=0; x<dim_x; ++x) {
+    var s = new X.slice();
+
+    var t = new X.texture();
+    t._rawDataWidth = texture_dim_y;
+    t._rawDataHeight = texture_dim_z;
+    t._rawData = slices_x[x];
+    t._grayscale = grayscale;
+    s._texture = t;    
+
+    s._width = dim_y*spacing_y;
+    s._height = dim_z*spacing_z;
+    s._center = [-Math.floor(dim_x*spacing_x/2) + x*spacing_x, 0, 0];
+    s._front = [1, 0, 0];
+    s._right = [0, 1, 0];
+    s._up = [0, 0, 1];
+    s._visible = false;
+    s._volume = object;
+    s._borders = false;
+    s.create_();
+
+    if (labelmap) {
+      s._labelmap = object._labelmap._children[0]._children[x];
+    }
+
+    if (x % x_y_sample_rate == 0) {
+      object._children[0]._children[x] = s;
+    }
+
+  }
+  for (var y=0; y<dim_y; ++y) {
+    var s = new X.slice();
+
+    var t = new X.texture();
+    t._rawDataWidth = texture_dim_x;
+    t._rawDataHeight = texture_dim_z;
+    t._rawData = slices_y[y];
+    t._grayscale = grayscale;
+    s._texture = t;
+
+    s._width = dim_x*spacing_x;
+    s._height = dim_z*spacing_z;
+    s._center = [0, -Math.floor(dim_y*spacing_y/2) + y*spacing_y, 0];
+    s._front = [0, 1, 0];
+    s._right = [1, 0, 0];
+    s._up = [0, 0, 1];
+    s._visible = false;
+    s._volume = object;
+    s._borders = false;
+    s.create_();
+
+    if (labelmap) {
+      s._labelmap = object._labelmap._children[1]._children[y];
+    }
+
+    if (y % x_y_sample_rate == 0) {
+      object._children[1]._children[y] = s;
+    }
+  }
+  for (var z=0; z<dim_z; ++z) {
+    var s = new X.slice();
+
+    var t = new X.texture();
+    t._rawDataWidth = texture_dim_x;
+    t._rawDataHeight = texture_dim_y;
+    t._rawData = slices_z[z];
+    t._grayscale = grayscale;
+    s._texture = t;    
+
+    s._width = dim_x*spacing_x;
+    s._height = dim_y*spacing_y;
+    s._center = [0, 0, -Math.floor(dim_z*spacing_z/2) + z*spacing_z];
+    s._front = [0, 0, 1];
+    s._right = [1, 0, 0];
+    s._up = [0, 1, 0];
+    s._visible = false;
+    s._volume = object;
+    s._borders = false;
+    s.create_();
+
+    if (labelmap) {
+      s._labelmap = object._labelmap._children[2]._children[z];
+    }
+
+    if (z % z_sample_rate == 0) {
+      object._children[2]._children[z] = s;
+    }
+  }
+
+
+  X.TIMERSTOP(this._classname + '.reslice');
+  
+
+};
diff --git a/io/parserRAW.js b/io/parserRAW.js
index a0183098e..c479f1ff3 100644
--- a/io/parserRAW.js
+++ b/io/parserRAW.js
@@ -127,13 +127,22 @@ X.parserRAW.prototype.parse = function(container, object, data, flag) {
   // grab the RAS Origin
   MRI.RASOrigin = [_rasBB[0], _rasBB[2], _rasBB[4]];
 
+  object._RASCenter = [0,0,0];
+
   // create the object
   object.create_(MRI);
 
   X.TIMERSTOP(this._classname + '.parse');
 
   // re-slice the data according each direction
-  object._image = this.reslice(object);
+  // object._image = 
+  // if (object._classname == 'labelmap') {
+  //   console.log('Labelmap');
+    
+  // } else {
+    this.reslice_old(object);
+    this.reslice(object);
+  // }
 
   // the object should be set up here, so let's fire a modified event
   var modifiedEvent = new X.event.ModifiedEvent();
diff --git a/objects/labelmap.js b/objects/labelmap.js
index c1cec8fe4..3872dfe6f 100644
--- a/objects/labelmap.js
+++ b/objects/labelmap.js
@@ -75,6 +75,14 @@ X.labelmap = function(volume) {
    */
   this._showOnlyColor = new Float32Array([-255, -255, -255, -255]);
 
+  this._32bit = false;
+
+  this._32bit_show_list = null;
+
+  this._gl_color_table = null;
+
+  this._gl_merge_table = null;
+
 };
 // inherit from X.volume
 goog.inherits(X.labelmap, X.volume);
@@ -97,6 +105,12 @@ X.labelmap.prototype.modified = function() {
 
 };
 
+X.labelmap.prototype.__defineSetter__('use32bit', function(flag) {
+
+  this._32bit = flag;
+
+});
+
 
 /**
  * Show only the label with the given value or color (RGBA 0..1). If null is passed,
diff --git a/objects/slice.js b/objects/slice.js
index 40b447dc7..536eabf3b 100644
--- a/objects/slice.js
+++ b/objects/slice.js
@@ -120,7 +120,7 @@ X.slice = function(slice) {
   /**
    * The label map of this slice which is a second texture.
    *
-   * @type {?X.texture}
+   * @type {?X.slice}
    * @protected
    */
   this._labelmap = null;
@@ -202,6 +202,18 @@ X.slice.prototype.__defineSetter__('width', function(width) {
 });
 
 
+/**
+ * Get the label map of this slice.
+ *
+ * @return {X.slice}
+ */
+X.slice.prototype.__defineGetter__('labelmap', function() {
+
+  return this._labelmap;
+
+});
+
+
 /**
  * Setup this X.slice and create it.
  *
diff --git a/objects/volume.js b/objects/volume.js
index f05f6438d..82e64d8a3 100644
--- a/objects/volume.js
+++ b/objects/volume.js
@@ -264,6 +264,24 @@ X.volume = function(volume) {
    */
   this._max = 0;
 
+  this._IJKVolume = null;
+
+  /**
+   * The sample rate for volumes in X-Y direction.
+   *
+   * @type {!number}
+   * @private
+   */
+  this._x_y_sample_rate = 1;
+
+  /**
+   * The sample rate for volumes in Z direction.
+   *
+   * @type {!number}
+   * @private
+   */
+  this._z_sample_rate = 1;
+
   /**
    * The image pixels
    *
@@ -460,7 +478,7 @@ X.volume.prototype.slicing_ = function() {
 
       //attach labelmap
       if(this.hasLabelMap){
-        var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[xyz]._sliceXYSpacing, this._childrenInfo[xyz]._sliceNormal, this._childrenInfo[xyz]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
+        var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[xyz]._sliceXYSpacing, this._childrenInfo[xyz]._sliceNormal, this._childrenInfo[xyz]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, null);
         this._labelmap._children[xyz]._children[parseInt(currentIndex, 10)] = _sliceLabel;
         // add it to create the texture
         this._labelmap._children[xyz].modified(true);
@@ -496,7 +514,7 @@ X.volume.prototype.slicing_ = function() {
 
     if(this._volumeRendering){
 
-      _currentSlice._children[0]._visible = false;
+      // _currentSlice._children[0]._visible = false;
       if(xyz != this._volumeRenderingDirection){
 
         _currentSlice['visible'] = false;
@@ -1310,6 +1328,58 @@ X.volume.prototype.__defineGetter__('zColor', function() {
 
 });
 
+/**
+ * Set value of the X-Y sample rate.
+ *
+ * @param {!number} xySampleRate the x-y sample rate, default: 1.
+ *
+ * @public
+ */
+X.volume.prototype.__defineSetter__('xySampleRate', function(xySampleRate) {
+
+  this._x_y_sample_rate = xySampleRate;
+
+});
+
+/**
+ * Get value of the X-Y sample rate.
+ *
+ * @return {!number}
+ *
+ * @public
+ */
+X.volume.prototype.__defineGetter__('xySampleRate', function() {
+
+  return this._x_y_sample_rate;
+
+});
+
+/**
+ * Set value of the Z sample rate.
+ *
+ * @param {!number} zSampleRate the z sample rate, default: 1.
+ *
+ * @public
+ */
+X.volume.prototype.__defineSetter__('zSampleRate', function(zSampleRate) {
+
+  this._z_sample_rate = zSampleRate;
+
+});
+
+/**
+ * Get value of the Z sample rate.
+ *
+ * @return {!number}
+ *
+ * @public
+ */
+X.volume.prototype.__defineGetter__('zSampleRate', function() {
+
+  return this._z_sample_rate;
+
+});
+
 /**
  * Recompute the slice information.
  * Only supports normals and color for now.
@@ -1434,18 +1504,20 @@ X.volume.prototype.volumeRendering_ = function(direction) {
 
     this._volumeRenderingCache.push(direction);
 
-    this._computing = true;
+    // this._computing = true;
 
-    // call computing callback
-    this.onComputing_(direction);
+    // // call computing callback
+    // this.onComputing_(direction);
 
   } else {
 
     // we do not need to reslice
 
     // hide old volume rendering slices
-    var _child = this._children[this._volumeRenderingDirection];
-    _child['visible'] = false;
+    if (this._volumeRenderingDirection != -1) {
+      var _child = this._children[this._volumeRenderingDirection];
+      _child['visible'] = false;
+    }
 
     // show new volume rendering slices, but don't show the borders
     _child = this._children[direction];
@@ -1453,8 +1525,9 @@ X.volume.prototype.volumeRendering_ = function(direction) {
 
     var i;
     for (i = 0; i < _numberOfSlices; i++) {
-
-      _child._children[i]._visible = true;
+      if (_child._children[i]) {
+        _child._children[i]._visible = true;
+      }
 
     }
 
@@ -1474,7 +1547,7 @@ X.volume.prototype.volumeRendering_ = function(direction) {
   //
 
     
-  setTimeout(function() {
+  // setTimeout(function() {
 
     // hide old volume rendering slices
     var _child = null;
@@ -1499,214 +1572,215 @@ X.volume.prototype.volumeRendering_ = function(direction) {
     //
 
     var i;
-    for (i = 0; i < 1*quarters; i++) {
+    for (i = 0; i < _numberOfSlices; i++) {
 
       // RESLICE VOLUME IF NECESSARY!
       //loop through slice
-      if(!goog.isDefAndNotNull(_child._children[i])){
+      // if(!goog.isDefAndNotNull(_child._children[i])){
 
-        var _sliceOrigin = goog.vec.Vec3.createFloat32();
+      //   var _sliceOrigin = goog.vec.Vec3.createFloat32();
 
-        _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
-        _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
-        _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
+      //   _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
+      //   _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
+      //   _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
 
-        //attach labelmap
-        if(this.hasLabelMap){
-          var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
-          this._labelmap._children[direction]._children[i] = _sliceLabel;
-          // add it to create the texture
-          this._labelmap._children[direction].modified(true);
-        }
+      //   //attach labelmap
+      //   if(this.hasLabelMap){
+      //     var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
+      //     this._labelmap._children[direction]._children[i] = _sliceLabel;
+      //     // add it to create the texture
+      //     this._labelmap._children[direction].modified(true);
+      //   }
 
-        var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
-        _slice._children[0]._visible = false;
+      //   var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
+      //   _slice._children[0]._visible = false;
 
-        if(this.hasLabelMap){
-          _slice._labelmap = _slice._texture;
-          _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
-        }
+      //   if(this.hasLabelMap){
+      //     _slice._labelmap = _slice._texture;
+      //     _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
+      //   }
 
-        _child._children[i] = _slice;
+      //   _child._children[i] = _slice;
 
-        _child._children[i]._visible = true;
-
-      }
-      else{
+      //   _child._children[i]._visible = true;
 
-        _child._children[i]._visible = true;
+      // }
+      // else{
+        if (_child._children[i]) {
+          _child._children[i]._visible = true;
+        }
 
-      }
+      // }
       
     }
 
-    this.onComputingProgress_(0.25);
+    // this.onComputingProgress_(0.25);
 
-    setTimeout(function() {
+    // setTimeout(function() {
 
-      for (; i < 2*quarters; i++) {
+      // for (; i < 2*quarters; i++) {
 
         // RESLICE VOLUME IF NECESSARY!
         //loop through slice
-        if(!goog.isDefAndNotNull(_child._children[i])){
+        // if(!goog.isDefAndNotNull(_child._children[i])){
 
-          var _sliceOrigin = goog.vec.Vec3.createFloat32();
+        //   var _sliceOrigin = goog.vec.Vec3.createFloat32();
 
-          _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
-          _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
-          _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
+        //   _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
+        //   _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
+        //   _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
 
-          //attach labelmap
-          if(this.hasLabelMap){
-            var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
-            this._labelmap._children[direction]._children[i] = _sliceLabel;
-            // add it to create the texture
-            this._labelmap._children[direction].modified(true);
-          }
+        //   //attach labelmap
+        //   if(this.hasLabelMap){
+        //     var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
+        //     this._labelmap._children[direction]._children[i] = _sliceLabel;
+        //     // add it to create the texture
+        //     this._labelmap._children[direction].modified(true);
+        //   }
 
-          var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
-          _slice._children[0]._visible = false;
+        //   var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
+        //   _slice._children[0]._visible = false;
 
-          if(this.hasLabelMap){
-            _slice._labelmap = _slice._texture;
-            _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
-          }
+        //   if(this.hasLabelMap){
+        //     _slice._labelmap = _slice._texture;
+        //     _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
+        //   }
 
-          _child._children[i] = _slice;
+        //   _child._children[i] = _slice;
 
-          _child._children[i]._visible = true;
+        //   _child._children[i]._visible = true;
 
-        }
-        else{
+        // }
+      //   // else{
 
-          _child._children[i]._visible = true;
+      //     _child._children[i]._visible = true;
 
-        } 
-      }
+      //   // } 
+      // }
 
-      this.onComputingProgress_(0.50);
+      // this.onComputingProgress_(0.50);
 
-      setTimeout(function() {
+      // setTimeout(function() {
 
-        for (; i < 3*quarters; i++) {
+        // for (; i < 3*quarters; i++) {
 
           // RESLICE VOLUME IF NECESSARY!
           //loop through slice
-          if(!goog.isDefAndNotNull(_child._children[i])){
+          // if(!goog.isDefAndNotNull(_child._children[i])){
 
-            var _sliceOrigin = goog.vec.Vec3.createFloat32();
+          //   var _sliceOrigin = goog.vec.Vec3.createFloat32();
 
-            _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
-            _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
-            _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
+          //   _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
+          //   _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
+          //   _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
 
-            //attach labelmap
-            if(this.hasLabelMap){
-              var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
-              this._labelmap._children[direction]._children[i] = _sliceLabel;
-              // add it to create the texture
-              this._labelmap._children[direction].modified(true);
-            }
+          //   //attach labelmap
+          //   if(this.hasLabelMap){
+          //     var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
+          //     this._labelmap._children[direction]._children[i] = _sliceLabel;
+          //     // add it to create the texture
+          //     this._labelmap._children[direction].modified(true);
+          //   }
 
-            var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
-            _slice._children[0]._visible = false;
+          //   var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
+          //   _slice._children[0]._visible = false;
 
-            if(this.hasLabelMap){
-              _slice._labelmap = _slice._texture;
-              _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
-            }
+          //   if(this.hasLabelMap){
+          //     _slice._labelmap = _slice._texture;
+          //     _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
+          //   }
 
-            _child._children[i] = _slice;
+          //   _child._children[i] = _slice;
 
-            _child._children[i]._visible = true;
+          //   _child._children[i]._visible = true;
 
-          }
-          else{
+          // }
+          // else{
 
-             _child._children[i]._visible = true;
+        //      _child._children[i]._visible = true;
 
-          } 
+        //   // } 
           
-        }
+        // }
 
-        this.onComputingProgress_(0.75);
+        // this.onComputingProgress_(0.75);
 
-        setTimeout(function() {
+        // setTimeout(function() {
 
-          for (i=3*quarters; i < _numberOfSlices; i++) {
+          // for (i=3*quarters; i < _numberOfSlices; i++) {
 
             // RESLICE VOLUME IF NECESSARY!
             //loop through slice
-            if(!goog.isDefAndNotNull(_child._children[i])){
+            // if(!goog.isDefAndNotNull(_child._children[i])){
 
-              var _sliceOrigin = goog.vec.Vec3.createFloat32();
+            //   var _sliceOrigin = goog.vec.Vec3.createFloat32();
 
-              _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
-              _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
-              _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
+            //   _sliceOrigin[0] = this._childrenInfo[direction]._solutionsLine[0][0][0] + this._childrenInfo[direction]._sliceDirection[0]*i;
+            //   _sliceOrigin[1] = this._childrenInfo[direction]._solutionsLine[0][0][1] + this._childrenInfo[direction]._sliceDirection[1]*i;
+            //   _sliceOrigin[2] = this._childrenInfo[direction]._solutionsLine[0][0][2] + this._childrenInfo[direction]._sliceDirection[2]*i;
 
-              //attach labelmap
-              if(this.hasLabelMap){
-                var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
-                this._labelmap._children[direction]._children[i] = _sliceLabel;
-                // add it to create the texture
-                this._labelmap._children[direction].modified(true);
-              }
+            //   //attach labelmap
+            //   if(this.hasLabelMap){
+            //     var _sliceLabel = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._labelmap._IJKVolume, this._labelmap, this._labelmap.hasLabelMap, this._labelmap._colortable._map);
+            //     this._labelmap._children[direction]._children[i] = _sliceLabel;
+            //     // add it to create the texture
+            //     this._labelmap._children[direction].modified(true);
+            //   }
 
-              var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
-              _slice._children[0]._visible = false;
+            //   var _slice = X.parser.reslice2(_sliceOrigin, this._childrenInfo[direction]._sliceXYSpacing, this._childrenInfo[direction]._sliceNormal, this._childrenInfo[direction]._color, this._BBox, this._IJKVolume, this, true, null);
+            //   _slice._children[0]._visible = false;
 
-              if(this.hasLabelMap){
-                _slice._labelmap = _slice._texture;
-                _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
-              }
+            //   if(this.hasLabelMap){
+            //     _slice._labelmap = _slice._texture;
+            //     _slice._labelmap = this._labelmap._children[direction]._children[i]._texture;
+            //   }
 
-              _child._children[i] = _slice;
+            //   _child._children[i] = _slice;
 
-              _child._children[i]._visible = true;
+            //   _child._children[i]._visible = true;
 
-            }
-            else{
+            // }
+          //   // else{
 
-             _child._children[i]._visible = true;
+          //    _child._children[i]._visible = true;
 
-            } 
+          //   // } 
 
-          }
+          // }
 
-          this.onComputingProgress_(1.0);
+          // this.onComputingProgress_(1.0);
 
-          setTimeout(function() {
+          // setTimeout(function() {
 
-            if (this._computing) {
+            // if (this._computing) {
 
               // add it to renderer!
               this._children[direction].modified(true);            
 
-            }
+            // }
 
             // store the direction
             this._volumeRenderingDirection = direction;
 
             this._dirty = false;      
 
-            if (this._computing) {
-              //call computing end callback
-              this.onComputingEnd_(direction);
+            // if (this._computing) {
+            //   //call computing end callback
+            //   this.onComputingEnd_(direction);
 
-            }
+            // }
 
-            this._computing = false;
+            // this._computing = false;
 
-          }.bind(this), 10);
+  //         }.bind(this), 10);
 
-        }.bind(this), 10);
+  //       }.bind(this), 10);
 
-      }.bind(this), 10);
+  //     }.bind(this), 10);
 
-    }.bind(this), 10);
+  //   }.bind(this), 10);
 
-  }.bind(this), 10);
+  // }.bind(this), 10);
 
 };
 
diff --git a/visualization/renderer.js b/visualization/renderer.js
index 459d830cf..ed352f064 100644
--- a/visualization/renderer.js
+++ b/visualization/renderer.js
@@ -401,6 +401,17 @@ X.renderer.prototype.onHover_ = function(event) {
 
 };
 
+/**
+ * Trigger viewport adjustment after resizing.
+ *
+ * @public
+ */
+X.renderer.prototype.onResize = function() {
+
+  this.onResize_();
+
+};
+
 
 /**
  * @protected
diff --git a/visualization/renderer3D.js b/visualization/renderer3D.js
index 54f0a2adb..224f40c53 100755
--- a/visualization/renderer3D.js
+++ b/visualization/renderer3D.js
@@ -567,7 +567,6 @@ X.renderer3D.prototype.update_ = function(object) {
   // different renderer) and does not need additional file loading but just the
   // gl texture setup
   if (goog.isDefAndNotNull(labelmap) && labelmap._dirty) {
-
     // run the update_ function on the labelmap object without jumping out
     this.update_(labelmap);
 
@@ -751,83 +750,110 @@ X.renderer3D.prototype.update_ = function(object) {
         _flipY = true;
       }
 
-      this._context.pixelStorei(this._context.UNPACK_FLIP_Y_WEBGL, _flipY);
-
-      // setup the glTexture, at this point the image for the texture was
-      // already
-      // loaded thanks to X.loader
-      var glTexture = this._context.createTexture();
+      if (texture._needs_update) {
 
-      // connect the image and the glTexture
-      glTexture.image = texture._image;
+        var glTexture = this._textures.get(texture._id);
+        this._context.bindTexture(this._context.TEXTURE_2D, glTexture);
 
-      //
-      // activate the texture on the WebGL side
-      this._textures.set(texture._id, glTexture);
-
-      this._context.bindTexture(this._context.TEXTURE_2D, glTexture);
-      if (texture._rawData) {
 
         var _texture_type = this._context.RGBA;
-        
-        if (texture._grayscale) {
-          
-          // one channel texture
-          _texture_type = this._context.LUMINANCE;
-          this._context.pixelStorei(this._context.UNPACK_ALIGNMENT, 1);
-          
-        }
 
-        // use rawData rather than loading an imagefile
         this._context.texImage2D(this._context.TEXTURE_2D, 0,
             _texture_type, texture._rawDataWidth, texture._rawDataHeight,
             0, _texture_type, this._context.UNSIGNED_BYTE,
             texture._rawData);
 
-      } else {
+        texture._dirty = false;
+        texture._needs_update = false;
 
-        // use an imageFile for the texture
-        this._context.texImage2D(this._context.TEXTURE_2D, 0,
-            this._context.RGBA, this._context.RGBA,
-            this._context.UNSIGNED_BYTE, glTexture.image);
+        object._dirty = false;
 
-      }
+        this._locked = false;
 
-      this._context.texParameteri(this._context.TEXTURE_2D,
-          this._context.TEXTURE_WRAP_S, this._context.CLAMP_TO_EDGE);
-      this._context.texParameteri(this._context.TEXTURE_2D,
-          this._context.TEXTURE_WRAP_T, this._context.CLAMP_TO_EDGE);
+        // we don't need anything else
+        return;
 
-      // for labelmaps, we use NEAREST NEIGHBOR filtering
-      if (isLabelMap) {
-        this._context.texParameteri(this._context.TEXTURE_2D,
-            this._context.TEXTURE_MAG_FILTER, this._context.NEAREST);
-        this._context.texParameteri(this._context.TEXTURE_2D,
-            this._context.TEXTURE_MIN_FILTER, this._context.NEAREST);
       } else {
+
+        this._context.pixelStorei(this._context.UNPACK_FLIP_Y_WEBGL, _flipY);
+
+        // setup the glTexture, at this point the image for the texture was
+        // already
+        // loaded thanks to X.loader
+        var glTexture = this._context.createTexture();
+
+        // connect the image and the glTexture
+        glTexture.image = texture._image;
+
+        //
+        // activate the texture on the WebGL side
+        this._textures.set(texture._id, glTexture);
+
+        this._context.bindTexture(this._context.TEXTURE_2D, glTexture);
+        if (texture._rawData) {
+
+          var _texture_type = this._context.RGBA;
+          
+          if (texture._grayscale) {
+            
+            // one channel texture
+            _texture_type = this._context.LUMINANCE;
+            this._context.pixelStorei(this._context.UNPACK_ALIGNMENT, 1);
+            
+          }
+
+          // use rawData rather than loading an imagefile
+          this._context.texImage2D(this._context.TEXTURE_2D, 0,
+              _texture_type, texture._rawDataWidth, texture._rawDataHeight,
+              0, _texture_type, this._context.UNSIGNED_BYTE,
+              texture._rawData);
+
+        } else {
+
+          // use an imageFile for the texture
+          this._context.texImage2D(this._context.TEXTURE_2D, 0,
+              this._context.RGBA, this._context.RGBA,
+              this._context.UNSIGNED_BYTE, glTexture.image);
+
+        }
+
         this._context.texParameteri(this._context.TEXTURE_2D,
-            this._context.TEXTURE_MAG_FILTER, this._context.LINEAR);
+            this._context.TEXTURE_WRAP_S, this._context.CLAMP_TO_EDGE);
         this._context.texParameteri(this._context.TEXTURE_2D,
-            this._context.TEXTURE_MIN_FILTER, this._context.LINEAR);
-      }
+            this._context.TEXTURE_WRAP_T, this._context.CLAMP_TO_EDGE);
+
+        // for labelmaps, we use NEAREST NEIGHBOR filtering
+        if (isLabelMap) {
+          this._context.texParameteri(this._context.TEXTURE_2D,
+              this._context.TEXTURE_MAG_FILTER, this._context.NEAREST);
+          this._context.texParameteri(this._context.TEXTURE_2D,
+              this._context.TEXTURE_MIN_FILTER, this._context.NEAREST);
+        } else {
+          this._context.texParameteri(this._context.TEXTURE_2D,
+              this._context.TEXTURE_MAG_FILTER, this._context.LINEAR);
+          this._context.texParameteri(this._context.TEXTURE_2D,
+              this._context.TEXTURE_MIN_FILTER, this._context.LINEAR);
+        }
 
-      // release the texture binding to clear things
-      this._context.bindTexture(this._context.TEXTURE_2D, null);
+        // release the texture binding to clear things
+        this._context.bindTexture(this._context.TEXTURE_2D, null);
 
-      // create texture buffer
-      var glTexturePositionBuffer = this._context.createBuffer();
+        // create texture buffer
+        var glTexturePositionBuffer = this._context.createBuffer();
 
-      // bind and fill with colors defined above
-      this._context.bindBuffer(this._context.ARRAY_BUFFER,
-          glTexturePositionBuffer);
-      this._context.bufferData(this._context.ARRAY_BUFFER, new Float32Array(
-          textureCoordinateMap), this._context.STATIC_DRAW);
+        // bind and fill with colors defined above
+        this._context.bindBuffer(this._context.ARRAY_BUFFER,
+            glTexturePositionBuffer);
+        this._context.bufferData(this._context.ARRAY_BUFFER, new Float32Array(
+            textureCoordinateMap), this._context.STATIC_DRAW);
 
-      // create an X.buffer to store the texture-coordinate map
-      texturePositionBuffer = new X.buffer(glTexturePositionBuffer,
-          textureCoordinateMap.length, 2);
+        // create an X.buffer to store the texture-coordinate map
+        texturePositionBuffer = new X.buffer(glTexturePositionBuffer,
+            textureCoordinateMap.length, 2);
 
-     this._texturePositionBuffers.set(id, texturePositionBuffer);
+       this._texturePositionBuffers.set(id, texturePositionBuffer);
+
+      }
 
       texture._dirty = false;
 
@@ -1444,6 +1470,75 @@ X.renderer3D.prototype.pick = function(x, y) {
 
 };
 
+X.renderer3D.prototype.updateFromDojo = function(colormap, colormaplength, mergetablekeys, mergetablevalues, mergetablelength, threeDlabels, threeDlabelslength, useThreeDlabels) {
+  var gl = this._context;
+
+
+  var merge_table_keys = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, merge_table_keys);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, mergetablelength, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, mergetablekeys);
+
+  // clamp to edge
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+
+  gl.bindTexture(gl.TEXTURE_2D, null);
+
+  var merge_table_values = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, merge_table_values);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, mergetablelength, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, mergetablevalues);
+  
+  // clamp to edge
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+
+  gl.bindTexture(gl.TEXTURE_2D, null);
+
+
+  // create colormap texture buffer
+  var colormap_texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, colormap_texture);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, colormaplength, 1, 0, gl.RGB, gl.UNSIGNED_BYTE, colormap);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+
+  gl.bindTexture(gl.TEXTURE_2D, null);
+
+  var threeD_labels_texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, threeD_labels_texture);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, threeDlabelslength, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, threeDlabels);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+
+  gl.bindTexture(gl.TEXTURE_2D, null);  
+
+
+  //
+  this._merge_table_keys = merge_table_keys;
+  this._merge_table_values = merge_table_values;
+  this._colormap_texture = colormap_texture;
+  this._colormap_length = colormaplength;
+  this._merge_table_length = mergetablelength;
+  this._threeD_labels_texture = threeD_labels_texture;
+  this._threeD_labels_length = threeDlabelslength;
+  this._use_threeD_labels = useThreeDlabels;
+
+};
+
 
 /**
  * @inheritDoc
@@ -1585,6 +1680,16 @@ X.renderer3D.prototype.render_ = function(picking, invoked) {
   var uObjectTransform = uLocations.get(X.shaders.uniforms.OBJECTTRANSFORM);
   var uPointSize = uLocations.get(X.shaders.uniforms.POINTSIZE);
 
+  var uColorMapSampler = uLocations.get(X.shaders.uniforms.COLORMAPSAMPLER);
+  var uMaxColors = uLocations.get(X.shaders.uniforms.MAXCOLORS);
+  var uMergeTableKeySampler = uLocations.get(X.shaders.uniforms.MERGETABLEKEYSAMPLER);
+  var uMergeTableValueSampler = uLocations.get(X.shaders.uniforms.MERGETABLEVALUESAMPLER);
+  var uMergeTableLength = uLocations.get(X.shaders.uniforms.MERGETABLELENGTH);
+  var uUse32bit = uLocations.get(X.shaders.uniforms.USE32BIT);
+  var uThreeDLabels = uLocations.get(X.shaders.uniforms.THREEDLABELS);
+  var uThreeDLabelsLength = uLocations.get(X.shaders.uniforms.THREEDLABELSLENGTH);
+  var uUseThreeDLabels = uLocations.get(X.shaders.uniforms.USETHREEDLABELS);
+
   //
   // loop through all objects and (re-)draw them
 
@@ -1854,11 +1959,13 @@ X.renderer3D.prototype.render_ = function(picking, invoked) {
 
           this._context.uniform1f(uObjectOpacity, parseFloat(volume._opacity));
 
-        } else if (labelmap && labelmap._visible) {
+        } 
+
+        if (labelmap && labelmap._visible) {
           // only if we have an associated labelmap..
           
           // grab the id of the labelmap
-          var labelmapTextureID = object._labelmap._id;
+          var labelmapTextureID = object._labelmap._texture._id;
 
           // we handle a second texture, actually the one for the labelmap
           this._context.uniform1i(uUseLabelMapTexture, true);
@@ -1868,8 +1975,9 @@ X.renderer3D.prototype.render_ = function(picking, invoked) {
 
           // grab the texture from the internal hash map using the id as
           // the key
-          this._context.bindTexture(this._context.TEXTURE_2D, this._textures
-              .get(labelmapTextureID));
+          this._context.bindTexture(this._context.TEXTURE_2D, this._textures.get(labelmapTextureID));
+
+          
           this._context.uniform1i(uTextureSampler2, 1);
 
           // propagate label map opacity
@@ -1878,6 +1986,37 @@ X.renderer3D.prototype.render_ = function(picking, invoked) {
           // propagate the labelmap show only color
           this._context.uniform4fv(uLabelMapColor, labelmap._showOnlyColor);
 
+          if (labelmap._32bit) {
+            // 32 bit labelmap
+            this._context.uniform1i(uUse32bit, 1);
+
+            var gl = this._context;
+            gl.activeTexture(gl.TEXTURE2);
+            gl.bindTexture(gl.TEXTURE_2D, this._colormap_texture);
+            gl.uniform1i(uColorMapSampler, 2);
+
+            gl.uniform1f(uMaxColors, this._colormap_length);
+
+            gl.activeTexture(gl.TEXTURE3);
+            gl.bindTexture(gl.TEXTURE_2D, this._merge_table_keys);
+            gl.uniform1i(uMergeTableKeySampler, 3);
+
+            gl.activeTexture(gl.TEXTURE4);
+            gl.bindTexture(gl.TEXTURE_2D, this._merge_table_values);
+            gl.uniform1i(uMergeTableValueSampler, 4);
+
+            gl.uniform1i(uMergeTableLength, this._merge_table_length);
+
+            gl.activeTexture(gl.TEXTURE5);
+            gl.bindTexture(gl.TEXTURE_2D, this._threeD_labels_texture);
+            gl.uniform1i(uThreeDLabels, 5);
+
+            gl.uniform1i(uThreeDLabelsLength, this._threeD_labels_length);
+
+            gl.uniform1i(uUseThreeDLabels, this._use_threeD_labels);
+
+          }
+
         }
 
       }
@@ -2396,6 +2535,29 @@ X.renderer3D.prototype.pick3d = function(x, y, delta, epsilon, object) {
 
 };
 
+
+/**
+ * Get the GL context.
+ */
+X.renderer3D.prototype.__defineGetter__('gl', function() {
+
+  return this._context;
+
+});
+
+X.renderer3D.prototype.__defineGetter__('textures', function() {
+
+  return this._textures;
+
+});
+
+X.renderer3D.prototype.getTexture = function(id) {
+
+  return this._textures.get(id);
+
+};
+
+
 // export symbols (required for advanced compilation)
 goog.exportSymbol('X.renderer3D', X.renderer3D);
 goog.exportSymbol('X.renderer3D.prototype.init', X.renderer3D.prototype.init);
@@ -2409,6 +2571,8 @@ goog.exportSymbol('X.renderer3D.prototype.render',
     X.renderer3D.prototype.render);
 goog.exportSymbol('X.renderer3D.prototype.destroy',
     X.renderer3D.prototype.destroy);
+goog.exportSymbol('X.renderer3D.prototype.onResize',
+    X.renderer3D.prototype.onResize);
 goog.exportSymbol('X.renderer3D.prototype.remove',
     X.renderer3D.prototype.remove);
 goog.exportSymbol('X.renderer3D.prototype.resetBoundingBox',
@@ -2417,3 +2581,7 @@ goog.exportSymbol('X.renderer3D.prototype.resetViewAndRender',
     X.renderer3D.prototype.resetViewAndRender);
 goog.exportSymbol('X.renderer3D.prototype.pick', X.renderer3D.prototype.pick);
 goog.exportSymbol('X.renderer3D.prototype.pick3d', X.renderer3D.prototype.pick3d);
+goog.exportSymbol('X.renderer3D.prototype.getTexture', X.renderer3D.prototype.getTexture);
+
+goog.exportSymbol('X.renderer3D.prototype.updateFromDojo',
+    X.renderer3D.prototype.updateFromDojo);
diff --git a/visualization/shaders.js b/visualization/shaders.js
index bfc5d39af..d320c440a 100644
--- a/visualization/shaders.js
+++ b/visualization/shaders.js
@@ -170,7 +170,7 @@ X.shaders = function() {
   this._fragmentshaderSource = '';
   var t2 = '';
   // android only guarantees medium precision
-  t2 += 'precision mediump float;\n';
+  t2 += 'precision mediump float;precision mediump int;\n';
   t2 += '\n';
   t2 += 'uniform bool usePicking;\n';
   t2 += 'uniform bool useTexture;\n';
@@ -189,6 +189,18 @@ X.shaders = function() {
   t2 += 'uniform vec3 volumeScalarMaxColor;\n';
   t2 += 'uniform float volumeWindowLow;\n';
   t2 += 'uniform float volumeWindowHigh;\n';
+  t2 += '\n';  
+  t2 += 'uniform bool uUse32bit;\n';
+  t2 += 'uniform sampler2D uColorMapSampler;\n';  
+  t2 += 'uniform sampler2D uMergeTableKeySampler;\n';  
+  t2 += 'uniform sampler2D uMergeTableValueSampler;\n';  
+  t2 += 'uniform sampler2D uThreeDLabels;\n';
+  t2 += 'uniform int uMergeTableLength;\n';
+  t2 += 'uniform float uMaxColors;\n';
+  t2 += 'uniform int uThreeDLabelsLength;\n';
+  t2 += 'uniform bool uUseThreeDLabels;\n';
+  t2 += '\n';
+  t2 += 'const int MAX = 10000;\n';
   t2 += '\n';
   t2 += 'varying float fDiscardNow;\n';
   t2 += 'varying vec4 fVertexPosition;\n';
@@ -197,14 +209,124 @@ X.shaders = function() {
   t2 += 'varying vec3 fVertexNormal;\n';
   t2 += 'varying vec3 fTransformedVertexNormal;\n';
   t2 += '\n';
+  t2 += '    //\n';
+  t2 += '    // 32 BIT <-> 8 BIT CONVERSIONS\n';
+  t2 += '    //\n';
+  t2 += '    // convert rgba to a 32 bit value\n';
+  t2 += '    float unpack (vec4 value) {\n';
+  t2 += '      // note: little endian\n';
+  t2 += '      const vec4 bitShifts = vec4( (256.0 * 256.0 * 256.0),\n';
+  t2 += '                                   (256.0 * 256.0),\n';
+  t2 += '                                   256.0,\n';
+  t2 += '                           1);\n';
+  t2 += '      return dot(value.abgr , bitShifts);\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '    // convert 32 bit int to rgba\n';
+  t2 += '    ivec4 pack (int value) {\n';
+  t2 += '\n';
+  t2 += '      ivec4 o = ivec4(0., 0., 0., 0.);\n';
+  t2 += '\n';
+  t2 += '      o.w = (value / (256*256*256));\n';
+  t2 += '      o.z = ((value-o.w) / (256*256));\n';
+  t2 += '      o.y = ((value-o.w-o.z) / (256));\n';
+  t2 += '      o.x = (value-o.y*256-o.z*256*256-o.w*256*256*256);\n';
+  t2 += '\n';
+  t2 += '      return o;\n';
+  t2 += '\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '    //\n';
+  t2 += '    // FLOAT COMPARE FUNCTIONS WITH DELTA\n';
+  t2 += '    //\n';
+  t2 += '    bool equals(float id1, float id2) {\n';
+  t2 += '      return (abs(id1-id2) <= 0.1);\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '    bool larger(float id1, float id2) {\n';
+  t2 += '\n';
+  t2 += '      if (equals(id1, id2)) return false;\n';
+  t2 += '\n';
+  t2 += '      return id1 > id2;\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '    //\n';
+  t2 += '    // ID LOOKUPS\n';
+  t2 += '    //\n';
+  t2 += '    float lookup_id_(float id) {\n';
+  t2 += '\n';
+  t2 += '      for (int m=0; m<MAX; m++) {\n';
+  t2 += '\n';
+  t2 += '        if (m>uMergeTableLength) break;\n';
+  t2 += '\n';
+  t2 += '        vec4 m_key = texture2D(uMergeTableKeySampler, vec2(float(m)/float(uMergeTableLength), 0.));\n';
+  t2 += '        float m_id = unpack(m_key)*255.;\n';
+  t2 += '\n';
+  t2 += '        // if m_id is larger than our id, then we are done since all entries are sorted\n';
+  t2 += '        if (larger(m_id, id)) break;\n';
+  t2 += '\n';
+  t2 += '        if (equals(id, m_id)) {\n';
+  t2 += '          // found entry\n';
+  t2 += '          vec4 m_value = texture2D(uMergeTableValueSampler, vec2(float(m)/float(uMergeTableLength), 0.));\n';
+  t2 += '          id = unpack(m_value)*255.;\n';
+  t2 += '\n';
+  t2 += '          return id;\n';
+  t2 += '        }\n';
+  t2 += '\n';
+  t2 += '      }\n';
+  t2 += '\n';
+  t2 += '      return id;\n';
+  t2 += '\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '    float lookup_id(float id) {\n';
+  t2 += '\n';
+  t2 += '      float new_id = id;\n';
+  t2 += '\n';
+  t2 += '      //\n';
+  t2 += '      // MERGE\n';
+  t2 += '      //\n';
+  t2 += '      for (int m=0; m < MAX; m++) {\n';
+  t2 += '\n';
+  t2 += '        new_id = lookup_id_(id);\n';
+  t2 += '\n';
+  t2 += '        if (equals(new_id, id)) {\n';
+  t2 += '          break;\n';
+  t2 += '        } else {\n';
+  t2 += '          id = new_id;\n';
+  t2 += '        }\n';
+  t2 += '\n';
+  t2 += '      }\n';
+  t2 += '\n';
+  t2 += '      return id;\n';
+  t2 += '\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += 'bool is_3d_label(float id) {\n';
+  t2 += '  for(int m=0; m<MAX; m++) {\n';
+  t2 += '\n';
+  t2 += '    if (m>uThreeDLabelsLength) break;\n';
+  t2 += '\n';
+  t2 += '    vec4 m_key = texture2D(uThreeDLabels, vec2(float(m)/float(uThreeDLabelsLength), 0.));\n';
+  t2 += '    float m_id = unpack(m_key)*255.;\n';
+  t2 += '\n';
+  t2 += '    if (larger(m_id, id)) break;\n';
+  t2 += '\n';
+  t2 += '    if (equals(id, m_id)) {\n';
+  t2 += '      return true;\n';
+  t2 += '    }\n';
+  t2 += '\n';
+  t2 += '  }\n';
+  t2 += '\n';
+  t2 += '  return false;\n';
+  t2 += '\n';
+  t2 += '}\n';
+  t2 += '\n';
   t2 += 'void main(void) {\n';
   t2 += ' if (fDiscardNow > 0.0) {\n';
   t2 += '   discard;\n'; // really discard now
   t2 += ' }\n';
-  // in picking mode, we don't want any extras but just the plain color
-  t2 += ' if (usePicking) {\n';
-  t2 += '   gl_FragColor = vec4(fragmentColor, 1.0);\n';
-  t2 += ' } else if (useTexture) {\n';
+  t2 += ' if (useTexture) {\n';
   t2 += '   vec4 texture1 = texture2D(textureSampler,fragmentTexturePos);\n';
   t2 += '   vec4 textureSum = texture1;\n';
   // perform window level
@@ -220,7 +342,17 @@ X.shaders = function() {
   t2 += '   }\n';
   t2 += '   if (useLabelMapTexture) {\n'; // special case for label maps
   t2 += '     vec4 texture2 = texture2D(textureSampler2,fragmentTexturePos);\n';
-  t2 += '     if (texture2.a > 0.0) {\n'; // check if this is not the background
+  t2 += '     if (uUse32bit) {\n';
+  t2 += '       float id = lookup_id(unpack(texture2)*255.);\n';
+  t2 += '       if (id == 0.) { discard;\n }';
+  t2 += '       float normalized_id = mod(id, uMaxColors);\n';
+  t2 += '       vec2 colormap_pos = vec2(normalized_id / (uMaxColors - 1.), 0.);\n';
+  t2 += '       vec4 color = texture2D(uColorMapSampler, colormap_pos);\n';
+  t2 += '       textureSum = mix(color, textureSum, 1.0 - labelmapOpacity);\n';
+  t2 += '       if (uUseThreeDLabels && !is_3d_label(id)) {\n';
+  t2 += '         discard;\n';
+  t2 += '       }\n';
+  t2 += '     } else if (texture2.a > 0.0) {\n'; // check if this is not the background
   // label
   t2 += '         if (labelmapColor.a != -255.0) {\n'; // check if only one color should be shown
   t2 += '           if (all(equal(floor(texture2 * vec4(255)), labelmapColor))) {\n'; // if equal, mix colors
@@ -244,14 +376,19 @@ X.shaders = function() {
   t2 += '   if (volumeTexture) {\n';
   t2 += '     float _volumeLowerThreshold = (volumeLowerThreshold / volumeScalarMax);\n';
   t2 += '     float _volumeUpperThreshold = (volumeUpperThreshold / volumeScalarMax);\n';
-  t2 += '     if (texture1.r < _volumeLowerThreshold ||\n';
-  t2 += '         texture1.r > _volumeUpperThreshold ||\n';
-  t2 += '         texture1.a == 0.0 ) {\n';
-  t2 += '       discard;\n';
-  t2 += '     };\n';
+  // t2 += '     if (texture1.r < _volumeLowerThreshold ||\n';
+  // t2 += '         texture1.r > _volumeUpperThreshold ||\n';
+  // t2 += '         texture1.a == 0.0 ) {\n';
+  // t2 += '       discard;\n';
+  // t2 += '     };\n';
   t2 += '   };\n';
-  t2 += '   gl_FragColor = textureSum;\n';
-  t2 += '   gl_FragColor.a = objectOpacity;\n';
+  // in picking mode, we don't want any extras but just the plain color  
+  t2 += '   if (usePicking) {\n';
+  t2 += '     gl_FragColor = vec4(fragmentColor,1.);\n';
+  t2 += '   } else {\n';
+  t2 += '     gl_FragColor = textureSum;\n';
+  t2 += '     gl_FragColor.a = objectOpacity;\n';
+  t2 += '   }\n';
   t2 += ' } else {\n';
   // configure advanced lighting
   t2 += '   vec3 nNormal = normalize(fTransformedVertexNormal);\n';
@@ -274,10 +411,15 @@ X.shaders = function() {
   t2 += '   float ambient = 0.3;\n';
   // .. and now setup the fragment color using these three values and the
   // opacity
-  t2 += '   gl_FragColor = vec4(fragmentColor * ambient +\n';
+  // in picking mode, we don't want any extras but just the plain color  
+  t2 += '   if (usePicking) {\n';
+  t2 += '     gl_FragColor = vec4(fragmentColor,1.);\n';
+  t2 += '   } else {\n';  
+  t2 += '     gl_FragColor = vec4(fragmentColor * ambient +\n';
   t2 += '                       fragmentColor * diffuse +\n';
   t2 += '                       vec3(0.2, 0.2, 0.2) * specular,\n';
   t2 += '                       objectOpacity);\n';
+  t2 += '   }\n';
   t2 += ' }\n';
   t2 += '}\n';
   this._fragmentshaderSource = t2;
@@ -343,7 +485,16 @@ X.shaders.uniforms = {
   VOLUMESCALARMAXCOLOR: 'volumeScalarMaxColor',
   VOLUMEWINDOWLOW: 'volumeWindowLow',
   VOLUMEWINDOWHIGH: 'volumeWindowHigh',
-  VOLUMETEXTURE: 'volumeTexture'
+  VOLUMETEXTURE: 'volumeTexture',
+  COLORMAPSAMPLER: 'uColorMapSampler',
+  MERGETABLEKEYSAMPLER: 'uMergeTableKeySampler',
+  MERGETABLEVALUESAMPLER: 'uMergeTableValueSampler',
+  MERGETABLELENGTH: 'uMergeTableLength',
+  USE32BIT: 'uUse32bit',
+  MAXCOLORS: 'uMaxColors',
+  USETHREEDLABELS: 'uUseThreeDLabels',
+  THREEDLABELS: 'uThreeDLabels',
+  THREEDLABELSLENGTH: 'uThreeDLabelsLength'
 };
 
 
diff --git a/xtk-deps.js b/xtk-deps.js
index f418419f5..4b28b042b 100644
--- a/xtk-deps.js
+++ b/xtk-deps.js
@@ -1,4 +1,4 @@
-// This file was autogenerated by /home/d/Projects/X/lib/google-closure-library/closure/bin/build/depswriter.py.
+// This file was autogenerated by /Users/d/Projects/X/lib/google-closure-library/closure/bin/build/depswriter.py.
 // Please do not edit.
 goog.addDependency('../../../../X.js', ['X', 'X.counter'], []);
 goog.addDependency('../../../../core/base.js', ['X.base'], ['X', 'goog.events', 'goog.events.EventTarget']);
@@ -74,11 +74,11 @@ goog.addDependency('../../../zlib.js/gzip.js', ['Zlib.Gzip'], ['Zlib.CRC32', 'Zl
 goog.addDependency('../../../zlib.js/gzip_member.js', ['Zlib.GunzipMember'], []);
 goog.addDependency('../../../zlib.js/heap.js', ['Zlib.Heap'], []);
 goog.addDependency('../../../zlib.js/huffman.js', ['Zlib.Huffman'], []);
-goog.addDependency('../../../zlib.js/inflate.js', ['Zlib.Inflate'], ['Zlib', 'Zlib.Adler32', 'Zlib.RawInflate']);
+goog.addDependency('../../../zlib.js/inflate.js', ['Zlib.Inflate'], ['Zlib', 'Zlib.Adler32', 'Zlib.RawInflate', 'Zlib.Util']);
 goog.addDependency('../../../zlib.js/inflate_stream.js', ['Zlib.InflateStream'], ['Zlib.RawInflateStream']);
 goog.addDependency('../../../zlib.js/rawdeflate.js', ['Zlib.RawDeflate'], ['Zlib.BitStream', 'Zlib.Heap']);
 goog.addDependency('../../../zlib.js/rawinflate.js', ['Zlib.RawInflate'], ['Zlib.Huffman']);
 goog.addDependency('../../../zlib.js/rawinflate_stream.js', ['Zlib.RawInflateStream'], ['Zlib.Huffman']);
 goog.addDependency('../../../zlib.js/use.js', ['USE_TYPEDARRAY'], []);
 goog.addDependency('../../../zlib.js/util.js', ['Zlib.Util'], []);
-goog.addDependency('../../../zlib.js/zlib.js', ['Zlib'], ['Zlib.Deflate', 'Zlib.Inflate']);
+goog.addDependency('../../../zlib.js/zlib.js', ['Zlib'], ['Zlib.Deflate']);